小兵向前冲

最新推荐文章于 2020-06-17 13:50:21 发布

fan2012huan

最新推荐文章于 2020-06-17 13:50:21 发布

阅读量1.5k

点赞数 1

分类专栏：程序文章标签：小兵向前冲递归记忆化搜索非递归 DP

本文链接：https://blog.csdn.net/fan2012huan/article/details/52514789

版权

程序专栏收录该内容

21 篇文章 0 订阅

订阅专栏

小兵向前冲

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

fan2012huan

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
小兵向前冲

小兵向前冲N*M的棋盘上，小兵要从左下角走到右上角，只能向上或者向右走，问有多少种走法？注意：这里说的N*M是指线段，而不是指几根竖线，几根横线。线段总是比线少1个的。下面的讨论都是基于线段的。见下图(这个图是4*4的)：上图标注解释如下：左下角黄色方框：起始位置右上角黄色方框：目标位置下边框和右边框黑色的数字0 1 2 3 4表示的是坐标红色的方框：表示递归时的重复
复制链接

扫一扫