一天算法（2019-12-7）

不同路径 II

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。
现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

网格中的障碍物和空位置分别用 1 和 0 来表示。
说明：m 和 n 的值均不超过 100。

示例 1:

输入:
[
  [0,0,0],
  [0,1,0],
  [0,0,0]
]
输出: 2
解释:
3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2 条不同的路径：
1. 向右 -> 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右 -> 向右

分析

这题跟不同路径增加了一个障碍物（假设a[n][m]为输入数组）

• 按照一贯习惯，压缩空间，使用一维数组来解决
• 首先考虑初始化，当然a[0][0]不可能有障碍，那么就考虑级器人横着走，一直走，如果遇到障碍物，这个各自及其后面的各自都为0，这样就不会对后面的结果造成影响。
• 然后递推公式：d[i] = d[i-1] + d[i]，显然这样还不够，因为还要考虑第一列有障碍物的情况，然后判断a[i][j]是否也有障碍，如果有，d[i] = 0

代码

    public static int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int n = obstacleGrid.length;
        int m = obstacleGrid[0].length;
        int[] a = new int[n];
        boolean flag = false;
        #初始化
        for (int i = 0; i < n; i++) {
            if (flag) {
                a[i] = 0;
            } else if (obstacleGrid[i][0] == 1) {
                flag = true;
                a[i] = 0;
            } else {
                a[i] = 1;
            }
        }

        for (int i = 1; i < m; i++) {
        	#第一列有障碍情况
            if (obstacleGrid[0][i] == 1) {
                a[0] = 0;
            }
            for (int j = 1; j < n; j++) {
            	#第obstacleGrid[j][i]有障碍物情况
                if (obstacleGrid[j][i] == 1) {
                    a[j] = 0;
                } else {
                    a[j] += a[j - 1];
                }
            }
        }
        return a[n - 1];
    }

最大子序和

这道题用动态规划的思路并不难解决，比较难的是后文提出的用分治法求解，但由于其不是最优解法，所以先不列出来

• 动态规划的是首先对数组进行遍历，当前最大连续子序列和为 sum，结果为 ans 如果 sum > 0，则说明 sum 对结果有增益效果，则
• sum 保留并加上当前遍历数字 如果 sum <= 0，则说明 sum 对结果无增益效果，需要舍弃，则 sum 直接更新为当前遍历数字
• 每次比较 sum 和 ans的大小，将最大值置为ans，遍历结束返回结果 时间复杂度：O(n)O(n)

代码

    public static int maxSubArray(int[] nums) {
        int max = nums[0];
        int sum = 0;
        for (int num:nums){
            if (sum>0){
                sum+=num;
            }else {
                sum=num;
            }
            max = Math.max(sum, max);
        }
        return max;
    }

最小路径和

给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

说明：每次只能向下或者向右移动一步。

示例:

输入:
[
  [1,3,1],
  [1,5,1],
  [4,2,1]
]
输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小。

分析

动态规划：我们知道从第一个开始，横着跟竖着只能一致往下走

第一行，跟第一列就直接d[0][i] += d[0][i-1]
第一列，d[i][0] += d[i-1][0]
状态转移，我们知道要走到d[i][j]，要么d[i-1][j]往下走，要么就是d[i][j-1]往右走，就会有

d[i][j] += min(d[i-1][j], d[i][j-1])

代码（这里做了空间压缩，直接源二维数组上直接计算，空间复杂度为O(1),时间复杂度O(mn)）

    public int minPathSum(int[][] grid) {
        for (int k = 1; k < grid[0].length; k++) {
            grid[0][k] += grid[0][k - 1];
        }
        for (int i = 1; i < grid.length; i++) {
            grid[i][0] += grid[i - 1][0];
            for (int j = 1; j < grid[0].length; j++) {
                grid[i][j] += Math.min(grid[i - 1][j], grid[i][j - 1]);
            }
        }
        return grid[grid.length - 1][grid[0].length - 1];
    }