小兵向前冲

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