象棋跳马问题(由暴力递归->动态规划)

跳马问题解释:

        象棋中马走日,从(0,0)点出发到达目标位置,规定走K步,问:能走到目标位置的所有方法数,象棋棋盘规模10*9大小。

    public static int jump(int a, int b, int K) {
        return process(0, 0, K, a, b);
    }

方法中的参数解释:

        1.int a和 int b,代表目标位置是(a,b)

        2.int K,代表总共走K步

开始暴力递归:

        假设当前位置在(x,y)处(任一位置),已经走了一部分,还剩下rest步需要走,目标位置是(a,b),那么在当前位置处一共八种可能性:(x+1,y+2)、(x+2,y+1)、(x+2,y-1)、(x+1,y-2)、(x-1,y-2)、(x-2,y-1)、(x-2,y+1)、(x-1,y+2),可以画一个坐标轴方便理解一点。

        考虑边界:当前位置(x,y)的八种可能性,如果跳出棋盘喃?那么则返回0种方法。

        递归退出条件:当剩余步数为0,并且刚好到达目标位置,退出递归,或者边界越界。

    /**
     * 当前位置(x,y);目标位置(a,b);还有rest步需要走
     * 棋盘规模:10*9
     *
     * @return 返回走完rest步到达目标位置的方法数
     */
    public static int process(int x, int y, int rest, int a, int b) {
        if (x < 0 || x > 9 || y < 0 || y > 8) {
            return 0;
        }
        if (rest == 0) {
            return (x == a && y == b) ? 1 : 0;
        }
        int p1 = process(x + 1, y + 2, rest - 1, a, b);
        int p2 = process(x + 2, y + 1, rest - 1, a, b);
        int p3 = process(x + 2, y - 1, rest - 1, a, b);
        int p4 = process(x + 1, y - 2, rest - 1, a, b);
        int p5 = process(x - 1, y - 2, rest - 1, a, b);
        int p6 = process(x - 2, y - 1, rest - 1, a, b);
        int p7 = process(x - 2, y + 1, rest - 1, a, b);
        int p8 = process(x - 1, y + 2, rest - 1, a, b);
        return p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8;
    }

 象棋跳马问题(由暴力递归->动态规划)_第1张图片

 动态规划:

        由分析可知,递归方法中,影响步数的是x、y、剩余步数rest这三个,显而易见是一个三维dp数组。当rest==0的时候,刚好到目标位置时,方法数是1,其余时候全是0。那么先确定rest==0的时候(也就是第一层)dp数组的值。然后会发现每一层的rest都是依赖下一层(rest-1)的dp数组的值,那么可以从下到上完成dp数组。要注意判断(x,y)跳到下一步之后是否越界。所以先写一个判断是否越界的方法,如果从当前位置跳完之后越界,那么返回0,不越界的话从dp数组中找到对应的值返回。

代码如下:

    //判断是否越界的方法
    public static int pick(int[][][] dp, int x, int y, int rest) {
        if (x < 0 || x > 9 || y < 0 || y > 8) {
            return 0;
        }
        return dp[x][y][rest];
    }

象棋跳马问题(由暴力递归->动态规划)_第2张图片

 有了这个方法之后完成dp数组:

    public static int jumpDP(int a, int b, int K) {
        int[][][] dp = new int[10][9][K + 1];
        dp[a][b][0] = 1;
        for (int rest = 1; rest < K + 1; rest++) {//rest从倒数第二层开始写
            for (int x = 0; x < 10; x++) {
                for (int y = 0; y < 9; y++) {
                    int p1 = pick(dp, x + 1, y + 2, rest - 1);
                    int p2 = pick(dp, x + 2, y + 1, rest - 1);
                    int p3 = pick(dp, x + 2, y - 1, rest - 1);
                    int p4 = pick(dp, x + 1, y - 2, rest - 1);
                    int p5 = pick(dp, x - 1, y - 2, rest - 1);
                    int p6 = pick(dp, x - 2, y - 1, rest - 1);
                    int p7 = pick(dp, x - 2, y + 1, rest - 1);
                    int p8 = pick(dp, x - 1, y + 2, rest - 1);
                    dp[x][y][rest] = p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8;
                }
            }
        }
        return dp[0][0][K];
    }

象棋跳马问题(由暴力递归->动态规划)_第3张图片

你可能感兴趣的:(java,动态规划,数据结构,算法)