机器人走路---暴力递归转动态规划

题目：假设有排成一行的N个位置，记为1~N，N 一定大于或等于 2 开始时机器人在其中的M位置上(M 一定是 1~N 中的一个) 如果机器人来到 1 位置，那么下一步只能往右来到 2 位置； 如果机器人来到N位置，那么下一步只能往左来到 N-1 位置； 如果机器人来到中间位置，那么下一步可以往左走或者往右走； 规定机器人必须走 K 步，最终能来到P位置(P也是1~N中的一个)的方法有多少种 给定四个参数 N、M、K、P，返回方法数。

public class RobotWalking {

    // 暴力递归
    public static int walk1(int N, int M, int K, int P) {
        if (N < 2 || M < 1 || M > N || P < 1 || P > N || K < 1) {
            return -1;
        }
        return process1(N, M, K, P);
    }

    /**
     * 暴力递归
     *
     * @param N N个位置，记为1~N
     * @param M 当前的位置
     * @param K 还剩多少步
     * @param P 目标位置
     * @return 方法数
     */
    private static int process1(int N, int M, int K, int P) {
        if (K == 0) {
            return M == P ? 1 : 0;
        }
        if (M == 1) {
            return process1(N, M + 1, K - 1, P);
        }
        if (M == N) {
            return process1(N, M - 1, K - 1, P);
        }
        return process1(N, M + 1, K - 1, P) + process1(N, M - 1, K - 1, P);
    }


    // 记忆化搜索
    public static int walk2(int N, int M, int K, int P) {
        if (N < 2 || M < 1 || M > N || P < 1 || P > N || K < 1) {
            return -1;
        }
        // 根据暴力递归可知 变化的参数 是M 和 K
        // M 的位置变化范围是 1 - N  K 的变化返回是 0 - K
        // 创建一个二维数组 可以装下所有的变化
        int[][] dp = new int[N + 1][K + 1];
        for (int i = 0; i <= N; i++) {
            for (int j = 0; j <= K; j++) {
                dp[i][j] = -1;
            }
        }
        return process2(N, M, K, P, dp);
    }

    private static int process2(int N, int M, int K, int P, int[][] dp) {
        if (dp[M][K] != -1) {
            return dp[M][K];
        }
        int ans;
        if (K == 0) {
            ans = M == P ? 1 : 0;
        } else if (M == 1) {
            ans = process1(N, M + 1, K - 1, P);
        } else if (M == N) {
            ans = process1(N, M - 1, K - 1, P);
        } else {
            ans = process1(N, M + 1, K - 1, P) + process1(N, M - 1, K - 1, P);
        }
        dp[M][K] = ans;
        return ans;
    }


    // 动态规划
    public static int walk3(int N, int M, int K, int P) {
        if (N < 2 || M < 1 || M > N || P < 1 || P > N || K < 1) {
            return -1;
        }
        int[][] dp = new int[N + 1][K + 1];
        dp[P][0] = 1;
//        for (int col = 1; col <= K; col++) {
//            for (int row = 1; row <=N; row++) {
//                if(row==1){
//                    dp[row][col] = dp[row + 1][col - 1];
//                }else if(row==N){
//                    dp[row][col] = dp[row - 1][col - 1];
//                }else {
//                    dp[row][col] = dp[row - 1][col - 1] +  dp[row + 1][col - 1];
//                }
//            }
//        }
        for (int col = 1; col <= K; col++) {
            dp[1][col] = dp[2][col - 1];
            for (int row = 2; row < N; row++) {
                dp[row][col] = dp[row - 1][col - 1] + dp[row + 1][col - 1];
            }
            dp[N][col] = dp[N - 1][col - 1];
        }
        return dp[M][K];
    }

    // 动态规划 空间压缩
    // col 为 k 的变化 从 0 - K   row为M的变化 从 1-N;
    // 创建的数组 变化范围是 [0...N] 0代表1位置 N-1代表N位置 所以P-1代表P位置
    // 根据暴力递归 当K == 0 row只有等于p的时候是1剩下的都是0
    // 第一行只依赖前一列的下面的值 最后一行依赖前一列上面的值 其他行依赖 自身所在位置的前一列的上一行和下一行的值的和
    // 举例:  N=5 M=2 K=6 P=4  建立一个长度为N的数组 0 代表 1 位置   N-1 代表N位置   所以P-1 代表P 位置 所以当k= 0  P-1 = 3 只有 第三行是1
    // 到第二列时 第二列的数据依赖第一列的数据
    // 第二列@符号依赖前一列的下一行@符号位置  第二列最后一行￥依赖前一列的上一行的￥位置 其余行%依赖前一列的上一行和下一行的%位置 根据暴力递归看出来的
    // 所以 才有如下的walk4
    // row  0       1  2  3  4  5  6       col
    //  0   0 %      @
    //  1   0 @     %
    //  2   0 %
    //  3   1 ￥
    //  4   0        ￥
    public static int walk4(int N, int M, int K, int P) {
        if (N < 2 || M < 1 || M > N || P < 1 || P > N || K < 1) {
            return -1;
        }
        int[] dp = new int[N];
        dp[P - 1] = 1;
        for (int col = 1; col <= K; col++) {
            int up = dp[0];
            dp[0] = dp[1];
            for (int row = 1; row < N - 1; row++) {
                int temp = dp[row];
                dp[row] = up + dp[row + 1];
                up = temp;
            }
            dp[N - 1] = up;
        }
        return dp[M - 1];
    }


    public static void main(String[] args) {
        System.out.println(walk1(5, 2, 6, 4));
        System.out.println(walk2(5, 2, 6, 4));
        System.out.println(walk3(5, 2, 6, 4));
        System.out.println(walk4(5, 2, 6, 4));
    }