回溯法和动态规划方法解UniquePath

出处：javascript-algorithms/src/algorithms/uncategorized/unique-paths at master · trekhleb/javascript-algorithms · GitHub

import java.util.Arrays;

/**
 * 唯一路径问题
 *
 * 机器人位于m * n网格左上角，只能向下或向右移动到达右下角
 * 求出，共有多少种可能的独特路径
 */
public class UniquePath {
    /**
     * 使用回溯法解决
     * @param m 矩阵行数
     * @param n 矩阵列数
     * @return 路径数
     */
    public static int backtraceUniquePath(int m, int n) {
        return helper(m, n, 0, 0);
    }

    private static int helper(int m, int n, int i, int j) {
        if (i == (m - 1) && j == (n - 1)) {
            return 1;
        }

        if (i > (m - 1) || j > (n - 1)) {
            return 0;
        }

        int right = helper(m, n, i, j + 1);
        int left = helper(m ,n, i + 1, j);
        return right + left;
    }

    /**
     * 使用动态规划
     * @param m
     * @param n
     * @return
     *
     * 【拆解子问题】
     * 因为要不就向下走要不就向右走，可以拆解为上面一步的个数 + 左边前一步的个数
     * BOARD[i][j] = BOARD[i - 1][j] + BOARD[i][j - 1];
     *
     * 【base case】
     * BOARD[0][j] = 1 最上面的slot只有一种走法能到达
     * BOARD[i][0] = 1 最左边的slot只有一种走法能到达
     */
    public static int dynamicUniquePath(int m, int n) {
        int[][] dp = new int[m][n];
        // 初始化base情况，第一列都为0
        for (int i = 0; i < m; i++) {
            dp[i][0] = 1;
        }
        // 初始化base情况，第一行都为0
        for (int j = 0; j < n; j++) {
            dp[0][j] = 1;
        }
        // 遍历数组求解，最后一个cell的值就是整个问题的解
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }

    /**
     * 空间优化的动态规划算法
     * @param m
     * @param n
     * @return
     *
     * 因为当前值只和他上面的cell及左边的cell有关，所以优化用一维数组记录结果
     */
    public static int optimizedDynamicUniquePath(int m, int n) {
        // 使用行数记录
        int[] dp = new int[m];
        // 都只有一种走法可以到达
        Arrays.fill(dp, 1);
        for (int j = 1; j < n; j++) {
            for (int i = 1; i < m; i++) {
                dp[i] += dp[i - 1];
            }
        }
        return dp[m - 1];
    }

    /**
     * 唯一路径的变种问题，增加了一个路障
     * 先用backtrace解决
     */
    public static int backtraceUniquePathStone(int[][] obstacleGrid) {
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        int[][] memo = new int[m][n];
        return helperStone(0, 0, m, n, obstacleGrid, memo);
    }

    /**
     * 此解法中添加记忆化递归方法
     */
    private static int helperStone(int i, int j, int m, int n, int[][] obstacleGrid, int[][] memo) {
        if (i == (m - 1) && j == (n - 1)) {
            return 1;
        }
        if (i > (m - 1) || j > (n - 1) || obstacleGrid[i][j] == 1) {
            return 0;
        }
        if (memo[i][j] != 0) {
            return memo[i][j];
        }

        int right = helperStone(i, j + 1, m, n, obstacleGrid, memo);
        int left = helperStone(i + 1, j, m, n, obstacleGrid, memo);
        memo[i][j] = right + left;
        return right + left;
    }

    /**
     * 动态规划版本
     * 相较于之前的动态规划的解法，此处只需要在遍历数组的时候加一个判断
     * 如果当前数组位置有障碍物，则路径走法个数归零
     */
    public static int optimizedDynamicUniquePathStone(int[][] obstacleGrid) {
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        // 使用行数记录
        int[][] dp = new int[m][n];
        // 初始化base情况，第一列都为0
        for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) {
            dp[i][0] = 1;
        }
        // 初始化base情况，第一行都为0
        for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) {
            dp[0][j] = 1;
        }
        // 遍历数组求解，最后一个cell的值就是整个问题的解
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (obstacleGrid[i][j] == 0) {
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                }
            }
        }
        return dp[m - 1][n - 1];
    }

    public static void main(String[] args) {
        System.out.println(" backtraceUniquePath result: " + backtraceUniquePath(3, 2));
        System.out.println(" dynamicUniquePath result: " + dynamicUniquePath(3, 2));
        System.out.println(" optimizedDynamicUniquePath result: " + optimizedDynamicUniquePath(3, 2));
        System.out.println(" ####################### ");
        int[][] obstacleGrid = new int[][]{{0, 0, 0}, {0,1,0}, {0,0,0}};
        System.out.println(" backtraceUniquePathStone result: " + backtraceUniquePathStone(obstacleGrid));
        System.out.println(" optimizedDynamicUniquePathStone result: " + optimizedDynamicUniquePathStone(obstacleGrid));
        System.out.println(" ####################### ");
        int[][] obstacleGrid2 = new int[][]{{0,1},{1,0}};
        System.out.println(" backtraceUniquePathStone result2: " + backtraceUniquePathStone(obstacleGrid2));
        System.out.println(" optimizedDynamicUniquePathStone result2: " + optimizedDynamicUniquePathStone(obstacleGrid2));

    }
}