每日一题：63. 不同路径 II

package com.ljp.test.leetcode;

/**
 * <b>63. 不同路径 II</b>
 *
 * <p>
 * 一个机器人位于一个m x n网格的左上角 （起始点在下图中标记为 “Start” ）。
 * <p>
 * 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。
 * <p>
 * 现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
 * <p>
 * 网格中的障碍物和空位置分别用 1 和 0 来表示。
 * <p>
 * <p>
 * 示例 1：
 * <p>
 * <p>
 * 输入：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
 * 输出：2
 * 解释：3x3 网格的正中间有一个障碍物。
 * 从左上角到右下角一共有 2 条不同的路径：
 * 1. 向右 -> 向右 -> 向下 -> 向下
 * 2. 向下 -> 向下 -> 向右 -> 向右
 * 示例 2：
 * <p>
 * <p>
 * 输入：obstacleGrid = [[0,1],[0,0]]
 * 输出：1
 * <p>
 * 提示：
 * <p>
 * m == obstacleGrid.length
 * n == obstacleGrid[i].length
 * 1 <= m, n <= 100
 * obstacleGrid[i][j] 为 0 或 1
 * <p>
 * 来源：力扣（LeetCode）
 * 链接：<a href="https://leetcode.cn/problems/unique-paths-ii">63. 不同路径 II</a>
 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 *
 * @author luojunping
 * @since 2023-03-09
 */
public class Number0063 {

    public static void main(String[] args) {
        int[][] nums1 = {{0, 0, 0}, {0, 1, 0}, {0, 0, 0}};
        int[][] nums2 = {{0, 1}, {0, 0}};
        System.out.println(DynamicPlanning.uniquePathsWithObstacles(nums1));
        System.out.println(DynamicPlanning.uniquePathsWithObstacles(nums2));
        System.out.println("---------------------------------------------");
        System.out.println(DynamicPlanning.uniquePathsWithObstaclesSpaceBetter(nums1));
        System.out.println(DynamicPlanning.uniquePathsWithObstaclesSpaceBetter(nums2));
    }

    private static class DynamicPlanning {

        public static int uniquePathsWithObstacles(int[][] nums) {
            int m = nums.length;
            int n = nums[0].length;
            int[][] dp = new int[m][n];
            for (int i = 0; i < m; i++) {
                if (nums[i][0] == 1) {
                    dp[i][0] = 0;
                } else {
                    dp[i][0] = 1;
                }
            }
            for (int i = 0; i < n; i++) {
                if (nums[0][i] == 1) {
                    dp[0][i] = 0;
                } else {
                    dp[0][i] = 1;
                }
            }
            for (int i = 1; i < m; i++) {
                for (int j = 1; j < n; j++) {
                    if (nums[i][j] == 1) {
                        dp[i][j] = 0;
                    } else {
                        dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                    }
                }
            }
            return dp[m - 1][n - 1];
        }

        public static int uniquePathsWithObstaclesSpaceBetter(int[][] nums) {
            int m = nums.length;
            int n = nums[0].length;
            int[] dp = new int[n];
            for (int i = 0; i < n; i++) {
                if (nums[0][i] == 1) {
                    dp[i] = 0;
                } else {
                    dp[i] = 1;
                }
            }
            for (int i = 1; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    if (nums[i][j] == 1) {
                        dp[j] = 0;
                    } else {
                        if (j == 0) {
                            dp[j] = 1;
                        } else {
                            dp[j] += dp[j - 1];
                        }
                    }
                }
            }
            return dp[n - 1];
        }
    }

}