小兵向前冲
小兵向前冲
N*M的棋盘上，小兵要从左下角走到右上角，只能向上或者向右走，问有多少种走法？
注意：这里说的N*M是指线段，而不是指几根竖线，几根横线。线段总是比线少1个的。下面的讨论都是基于线段的。
见下图(这个图是4*4的)：
上图标注解释如下：
左下角黄色方框：起始位置
右上角黄色方框：目标位置
下边框和右边框黑色的数字0 1 2 3 4表示的是坐标
红色的方框：表示递归时的重复计算量
其实这是一个数学的组合问题：
从左下角走到右上角总共只需要走8步（要么向右走4步，要么向上走4步），这样只需要C(8,4)就可以了。
递归代码
package org.fan.learn.dp;
/**
* Created by fan on 2016/9/12.
*/
public class LittleSoldier {
//定义x轴有N个格子，y轴有M个格子
private static final int N = 10;
private static final int M = 10;
private static int[][] result;
public static int search(int xi, int yi) {
if (xi == 0 || yi == 0) {
return 1;
}
//记忆化搜索
if (result[xi][yi] >= 0) {
return result[xi][yi];
}
result[xi][yi] = search(xi-1, yi) + search(xi, yi-1);
return result[xi][yi];
}
public static void main(String[] args) {
result = new int[N+1][M+1];
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= M; j++) {
result[i][j] = -1;
}
}
long start = System.currentTimeMillis();
System.out.println(search(N, M));
System.out.println("Time:" + (System.currentTimeMillis() - start) + " ms");
}
}
运行结果如下：
//不用记忆化搜索
184756
Time:7 ms
//使用记忆化搜索
184756
Time:1 ms
递推实现
public static int searchDitui(int xi, int yi) {
for (int i = 0; i <= N; i++) {
result[i][0] = 1;
}
for (int j = 0; j <= M; j++) {
result[0][j] = 1;
}
//i j是从1开始的
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
result[i][j] = result[i-1][j] + result[i][j-1];
}
}
return result[xi][yi];
}完整实现
package org.fan.learn.dp;
/**
* Created by fan on 2016/9/12.
*/
public class LittleSoldier {
//定义x轴有N个格子，y轴有M个格子
private static final int N = 10;
private static final int M = 10;
private static int[][] result;
public static int search(int xi, int yi) {
if (xi == 0 || yi == 0) {
return 1;
}
//记忆化搜索
if (result[xi][yi] >= 0) {
return result[xi][yi];
}
result[xi][yi] = search(xi-1, yi) + search(xi, yi-1);
return result[xi][yi];
}
public static int searchDitui(int xi, int yi) {
for (int i = 0; i <= N; i++) {
result[i][0] = 1;
}
for (int j = 0; j <= M; j++) {
result[0][j] = 1;
}
//i j是从1开始的
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
result[i][j] = result[i-1][j] + result[i][j-1];
}
}
return result[xi][yi];
}
public static void main(String[] args) {
result = new int[N+1][M+1];
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= M; j++) {
result[i][j] = -1;
}
}
long start = System.currentTimeMillis();
System.out.println(search(N, M));
System.out.println("Time:" + (System.currentTimeMillis() - start) + " ms");
long start2 = System.currentTimeMillis();
System.out.println(searchDitui(N, M));
System.out.println("Time:" + (System.currentTimeMillis() - start2) + " ms");
}
}
运行结果：
184756
Time:1 ms
184756
Time:0 ms
小兵先前冲，某点不能走
数学分析
如果在上面的点中，（3，3）点是不能走的。那怎么办？
现在来看下面的图，这个图是是个7*5的图。
先用数学分析下：
记（0，0）点为A点，（7，5）点为B点，（3，3）点为P点。
从A->B点总共C(12,5)种走法。
从A->P点总共C(6,3)种走法。
从P->B点总共C(6,2)种走法。
由于P点不能走，那么经过P点，从A点走到B点有几种走法呢？
C(6,3)*C(6,2)种走法。
因此，不经过P点的走法：C(12,5)-C(6,3)*C(6,2)=492种走法。
注意，这个结果跟不经过哪个点有直接关系。
比如现在改为（2，2）点不能走，则：
C(12,5)-C(4,2)*C(8,3)=456种。
代码实现
要到达R点需要经过P点和Q点，这时P不能走，则只需要置为0即可。即：search(4,3) = 0 + search(4,2);
也就是说，遇到（3，3）这个点就返回0。
代码实现如下所示：
package org.fan.learn;
/**
* Created by thinkpad on 2016/9/12.
*/
public class LittleSoldier {
//定义x轴有N个格子，y轴有M个格子
private static final int N = 7;
private static final int M = 5;
//(XNO,YNO)这个点表示不能走
private static final int XNO = 3;
private static final int YNO = 3;
private static int[][] result;
public static int search(int xi, int yi) {
if (xi == 0 || yi == 0) {
return 1;
}
//(XNO,YNO)这个点表示不能走
if (xi == XNO && yi == YNO) {
return 0;
}
//记忆化搜索
if (result[xi][yi] >= 0) {
return result[xi][yi];
}
result[xi][yi] = search(xi-1, yi) + search(xi, yi-1);
return result[xi][yi];
}
public static int searchDitui(int xi, int yi) {
for (int i = 0; i <= N; i++) {
result[i][0] = 1;
}
for (int j = 0; j <= M; j++) {
result[0][j] = 1;
}
//i j是从1开始的
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
//(XNO,YNO)这个点表示不能走
if (i == XNO && j == YNO) {
result[XNO][YNO] = 0;
} else {
result[i][j] = result[i-1][j] + result[i][j-1];
}
}
}
return result[xi][yi];
}
public static void main(String[] args) {
result = new int[N+1][M+1];
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= M; j++) {
result[i][j] = -1;
}
}
long start = System.currentTimeMillis();
System.out.println(search(N, M));
System.out.println("Time:" + (System.currentTimeMillis() - start) + " ms");
long start2 = System.currentTimeMillis();
System.out.println(searchDitui(N, M));
System.out.println("Time:" + (System.currentTimeMillis() - start2) + " ms");
}
}
运行结果如下：
492
Time:1 ms
492
Time:0 ms
小兵向前冲，往上、右可以走1步或两步
package org.fan.learn.dp;
/**
* Created by fan on 2016/9/12.
*/
public class LittleSoldier {
//定义x轴有N个格子，y轴有M个格子
private static final int N = 2;
private static final int M = 2;
private static int[][] result;
public static int search(int xi, int yi) {
if (xi == 0 || yi == 0) {
return 1;
}
if (xi < 0 || yi < 0) {
return 0;
}
//记忆化搜索
if (result[xi][yi] >= 0) {
return result[xi][yi];
}
result[xi][yi] = search(xi-1, yi) + search(xi, yi-1) + search(xi-2, yi) + search(xi, yi-2);
return result[xi][yi];
}
public static int searchDitui(int xi, int yi) {
for (int i = 0; i <= N; i++) {
result[i][0] = 1;
}
for (int j = 0; j <= M; j++) {
result[0][j] = 1;
}
result[1][1] = result[0][1] + result[1][0];
//不要忘了走到（2,1）点会有走1步或者走2步的情况
for (int i = 2; i <= N; i++) {
result[i][1] = result[i-1][1] + result[i][0] + result[i-2][1];
}
for (int j = 2; j <= M; j++) {
result[1][j] = result[1][j-1] + result[0][j] + result[1][j-2];
}
//i j是从1开始的
for (int i = 2; i <= N; i++) {
for (int j = 2; j <= M; j++) {
result[i][j] = result[i-1][j] + result[i][j-1] + result[i-2][j] + result[i][j-2];
}
}
return result[xi][yi];
}
public static void main(String[] args) {
result = new int[N+1][M+1];
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= M; j++) {
result[i][j] = -1;
}
}
long start = System.currentTimeMillis();
System.out.println(search(N, M));
System.out.println("Time:" + (System.currentTimeMillis() - start) + " ms");
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= M; j++) {
result[i][j] = -1;
}
}
long start2 = System.currentTimeMillis();
System.out.println(searchDitui(N, M));
System.out.println("Time:" + (System.currentTimeMillis() - start2) + " ms");
}
}
运行结果如下：
10
Time:0 ms
10
Time:0 ms
递推要比递归难写。因为要考虑很多特殊情况。最常见的就是，数组下标不要出现负数以及不要越界。这样，对于使得数组下标出现负数的情况，需要特殊赋初值。就像上面的写法一样。
组合问题
从n个东西里去m个：
C(n,m) = C(n-1, m-1) + C(n-1, m)
C(n-1, m-1)表示第n个东西被选了
C(n-1, m)表示第n个东西没有被选
package org.fan.learn.dp;
/**
* Created by fan on 2016/9/12.
*/
public class Cnm {
private static final int N = 20;
private static final int M = 10;
private static int[][] result;
//开启了无脑模式
public static int cnmDigui(int n, int m) {
if (n < m) {
return 0;
}
if (m == 0) {
return 1;
}
//记忆化搜索
if (result[n][m] >= 0) {
return result[n][m];
}
result[n][m] = cnmDigui(n - 1, m - 1) + cnmDigui(n - 1, m);
return result[n][m];
}
//这个写的好无脑
public static int cnmDitui(int n, int m) {
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= M; j++) {
if (i == j || j == 0) {
result[i][j] = 1;
}
if (i < j) {
result[i][j] = 0;
}
}
}
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
result[i][j] = result[i-1][j-1] + result[i-1][j];
}
}
return result[n][m];
}
public static void main(String[] args) {
result = new int[N+1][M+1];
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= M; j++) {
result[i][j] = -1;
}
}
long start = System.currentTimeMillis();
System.out.println(cnmDigui(N, M));
System.out.println("Time:" + (System.currentTimeMillis() - start) + " ms");
long start2 = System.currentTimeMillis();
System.out.println(cnmDitui(N, M));
System.out.println("Time:" + (System.currentTimeMillis() - start2) + " ms");
}
}
运行结果：
184756
Time:0 ms
184756
Time:0 ms