过河卒-动态规划+高精度
http://www.rqnoj.cn/Problem_69.html
题目:过河卒
问题编号:69
题目描述
如图，A 点有一个过河卒，需要走到目标 B 点。卒行走规则：可以向下、或者向右。同时在棋盘上的任一点有一个对方的马（如上图的C点），该马所在的点和所有跳跃一步可达的点称为对方马的控制点。例如上图 C 点上的马可以控制 9 个点（图中的P1，P2 … P8 和 C）。卒不能通过对方马的控制点。
棋盘用坐标表示，A 点（0，0）、B 点（n,m）(n,m 为不超过 25 的整数，并由键盘输入)，同样马的位置坐标是需要给出的（约定: C<>A，同时C<>B）。现在要求你计算出卒从 A 点能够到达 B 点的路径的条数。
输入格式
键盘输入
B点的坐标（n,m）以及对方马的坐标（X,Y）{不用盘错}
输出格式
屏幕输出
一个整数（路径的条数）。
样例输入
6 6 3 2
样例输出
一、思路
感觉这是个回溯或者暴力求解的题目，怎么就可以用动态规划，发现还真可以
根据题目和加法原理
f(n,m) = f(n-1,m) + f(n, m-1) 上方和左方的可达路径之和，最优子结构
f(n-1, m) = f(n-2, m) + f(n-1, m-1)
f(n, m-1) = f(n-1, m-1) + f(n, m-2)
重复了f(n-1, m-1) 后面会重复更多，子问题重叠
利用2维数组来描述f[i][j]
怎么来递推求解，初始条件是什么
原本我想从0.0开始向右，向下，发现要考虑的边界条件和马的控制点，太多了
还是从递推式入手容易，初始条件为
f[0][i]，第一行，只像右移动
f[i][0]，第一列，只像下移动
然后从1,1开始求解，将马足控制点设为-2，此点不走，且，如果上或者左侧点为它，则把它记为0路径相加
if (f[i][j]==-2) continue;
f[i][j] = f[i-1][j]<0 ? 0 : f[i-1][j]
f[i][j] += f[i][j-1]<0 ? 0 : f[i][j-1];
因为题目最大数据为50里取25的排序数，用高精度
所以又加了第三维，来描述位数
二、算法
f[26][26][2]，来描述当走到第i,j位置时的路径数f[i][j][2](低位为[0]，高位为[1])
结构体 horse[9] 来描述定义，9个马的控制方位，用于初始化为：-2
1、读入b:n,m ;x,y
2、初始化
f[0][i]和f[i][0]和f[0][0]=1
3、动态规划求解，二重循环
第一重：行
第二重：列
高精度，加法
4、输出结果f[n][m][0-1]
输出最高位
补0输出低位
三、错误总结
先是没有用高精度，只有2个得分点
后面用了，是6个得分点
1630 -->1645 输出的结果，比正确的少了十几个路径数
那么高精度和动态规划算法总体应该是没问题的，
最后发现是在初始化行列的时候，将n,m位置写错导致
终于AC
代码如下：
#include
#include
struct Point
{
int x;
int y;
};
#define BITS 10000000
//输出测试结果
void PrintF(int f[26][26][2], int n, int m)
{
/*
cout<>n>>m>>x>>y;
//inFile>>n>>m>>x>>y;
//初始化，马的控制点,设为，-2
for (i=0; i<9; i++)
{
if (x+horse[i].x>=0 && y+horse[i].y>=0)
{
f[x+horse[i].x][y+horse[i].y][0] = -2;
}
}
PrintF(f, n, m);
//初始化第一行
f[0][0][0] = 1;
for (i=1; i<=m; i++)
{
if (f[0][i][0] == -2)
{
continue;
}
f[0][i][0] = f[0][i-1][0]<0 ? 0 : f[0][i-1][0];
}
//初始化第一列
for (i=1; i<=n; i++)
{
if (f[i][0][0] == -2)
{
continue;
}
f[i][0][0] = f[i-1][0][0]<0 ? 0 : f[i-1][0][0];
}
PrintF(f, n, m);
//动态规划求解
//f(i,j)=f(i-1,j)+f(i, j-1);
for (i=1; i<=n; i++)
{
for (j=1; j<=m; j++)
{
if (f[i][j][0] == -2)
{
continue;
}
f[i][j][0] += f[i-1][j][0]<0 ? 0 : f[i-1][j][0];
f[i][j][1] += f[i-1][j][1];
f[i][j][0] += f[i][j-1][0]<0 ? 0 : f[i][j-1][0];
if (f[i][j][0]>BITS)
{
f[i][j][1] += f[i][j][0]/BITS;
f[i][j][0] = f[i][j][0]%BITS;
}
f[i][j][1] += f[i][j-1][1];
}
}
PrintF(f, n, m);
//输出结果
//找到最高位
i=1;
while (!f[n][m][i])
{
i--;
}
//输出最高位
cout<=0; j--)
{
//判断位数
int bit = 10;
int cnt;
for (cnt=1; cnt<=7; cnt++)
{
if (f[n][m][j]/bit==0)
{
break;
}
bit *= 10;
}
//输出0
for (int k=1; k<=7-cnt; k++)
{
cout<<0;
}
cout<