过河卒问题的动态规划求解（分支限界或者回溯过于耗时）

如图，A 点有一个过河卒，需要走到目标 B 点。卒行走规则：可以向下、或者向右。同时在棋盘上的任一点有一个对方的马（如上图的C点），该马所在的点和所有跳跃一步可达的点称为对方马的控制点。例如上图 C 点上的马可以控制 9 个点（图中的P1，P2 … P8 和 C）。卒不能通过对方马的控制点。

#include <memory.h>#include "OJ.h"

#define MAX_AXIS 21

#define HORSEMAX 9

/*

功能:计算出卒从 A 点(0,0)能够到达 B 点的路径的条数。

输入参数：

int B_axis[2]: B点所在位置的坐标，B_axis[0]:横坐标，B_axis[1]:纵坐标

int C_axis[2]：马所在位置的坐标，C_axis[0]:横坐标，C_axis[1]:纵坐标

输出参数：

long long result: 返回从A点（绕过C点所控制区域）到B点的路径条数

返回值：

无

*/

void GetResult(int B_axis[2], int C_axis[2], long long & result)

{

long long pathCnt[MAX_AXIS][MAX_AXIS] = {0};

bool availPos[MAX_AXIS][MAX_AXIS];

int horseJump[HORSEMAX][2] = {{2,1},{2,-1},{-2,-1},{-2,1},{1,2},{-1,2},{1,-2},{-1,-2},{0,0}};//马可以到达的范围

for (int i = 0 ; i < HORSEMAX ; i++)

{

if ((horseJump[i][0] + C_axis[0]) < 0 || (horseJump[i][1] + C_axis[1]) < 0)

{

continue;

}

availPos[horseJump[i][0] + C_axis[0]][horseJump[i][1] + C_axis[1]] = false;

}

pathCnt[0][0] = 1;

int i, j;

for (i = 0 ; i <= B_axis[0] ; i++)

{

for (j = 0 ; j <= B_axis[1]; j++)

{

if ((i - 1) < 0 && (j - 1) >= 0 && availPos[i][j]) //沿着水平边线走的话路径只有一条

{

pathCnt[i][j] = pathCnt[i][j - 1];

}

if ((i - 1) >= 0 && (j - 1) < 0 && availPos[i][j])//沿着竖直边线走的话路径只有一条

{

pathCnt[i][j] = pathCnt[i - 1][j];

}

if((i - 1) >= 0 && (j - 1) >= 0 && availPos[i][j]) //一旦离开了水平和竖直边线，路径的条数就是横着过来和竖着过来的和

{

pathCnt[i][j] = pathCnt[i - 1][j] + pathCnt[i][j - 1];

}

}

}

result = pathCnt[B_axis[0]][B_axis[1]];

}

回溯法求解：

public class Demo {

/**

*

* 功能:计算出卒从 A 点(0,0)能够到达 B 点的路径的条数。

* @param B_axis B点所在位置的坐标，B_axis[0]:横坐标，B_axis[1]:纵坐标

* @param C_axis 马所在位置的坐标，C_axis[0]:横坐标，C_axis[1]:纵坐标

* @return 返回从A点（绕过C点所控制区域）到B点的路径条数

*/

class Point

{

Point(int a,int b){x=a;y=b;}

int x;

int y;

}

int traceCount=0;

Point curr;

Point []path;

Point des;

Point horse;

Boolean checkVacancy(Point p)

{

if((p.x==horse.x)&&(p.y==horse.y)) return false;

if((Math.abs(p.x-horse.x)==2)&&(Math.abs(p.y-horse.y)==1)) return false;

if((Math.abs(p.x-horse.x)==1)&&(Math.abs(p.y-horse.y)==2)) return false;

if(p.x>des.x||p.y>des.y) return false;

return true;

}

void stepBack(String dir)

{

if(dir=="left") curr.y--;

if(dir=="up") curr.x--;

}

Boolean Exceed()

{

if(curr.x>des.x)

{

curr.x--;

return true;

}

if(curr.y>des.y)

{

curr.y--;

return true;

}

return false;

}

Boolean stepRight()

{

if(checkVacancy(new Point(curr.x,curr.y+1)))

{

curr.y+=1;

return true;

}

return false;

}

Boolean stepDown()

{

if(checkVacancy(new Point(curr.x+1,curr.y)))

{

curr.x+=1;

return true;

}

return false;

}

void debug()

{

System.out.println("the curr x:"+curr.x+" the y:"+curr.y);

}

void backTrace(int t,int h)

{

//debug();

if((curr.x==des.x)&&(curr.y==des.y))

{

traceCount++;

return; //递归出口

}

if(stepRight())

{

backTrace(t+1,h);

stepBack("left");

}

if(stepDown())

{

backTrace(t,h+1);

stepBack("up");

}

}

public long getResult(int[] B_axis, int[] C_axis) {

// coding

if(B_axis==null||C_axis==null) return 0;

if(B_axis.length!=2||C_axis.length!=2)return 0;

des=new Point(B_axis[0],B_axis[1]);

horse=new Point(C_axis[0],C_axis[1]);

if(des.x<0||des.y<0) return 0;

if((des.x==horse.x)||(des.y==horse.y)) return 0;

curr=new Point(0,0);

traceCount=0;

backTrace(0,0);

return traceCount;

}

}