day19

day19

968. 监控二叉树

​​力扣题目链接​​

题目

给定一个二叉树，我们在树的节点上安装摄像头。

节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。

计算监控树的所有节点所需的最小摄像头数量。

示例 1：

输入：[0,0,null,0,0]
输出：1

示例 2：

输入：[0,0,null,0,null,0,null,null,0]
输出：2

提示：

1.给定树的节点数的范围是 [1, 1000]。
2.每个节点的值都是 0。

思路

应该用后序遍历从下到上进行推导

• 情况一：左右节点都有覆盖

左孩子有覆盖，右孩子有覆盖，那么此时中间节点应该就是无覆盖的状态了

• 情况二：左右节点至少有一个无覆盖的情况

• 情况三：左右节点至少有一个有摄像头
• 情况四：头结点没有覆盖

代码实现

/**
 * https://leetcode-cn.com/problems/binary-tree-cameras/
 * 0：该节点无覆盖
 * 1：本节点有摄像头
 * 2：本节点有覆盖
 *
 * @author xiexu
 * @create 2022-04-02 20:18
 */
public class _968_监控二叉树 {

    int result = 0;

    public int minCameraCover(TreeNode root) {
        result = 0;
        // 情况4
        if (traversal(root) == 0) { // root 无覆盖
            result++;
        }
        return result;
    }

    private int traversal(TreeNode root) {
        // 如果是空节点，应该设置该节点有覆盖
        if (root == null) {
            return 2;
        }

        int left = traversal(root.left); // 左
        int right = traversal(root.right); // 右

        // 情况1
        // 左右节点都有覆盖
        if (left == 2 && right == 2) {
            return 0;
        }

        // 情况2
        // left == 0 && right == 0 左右节点无覆盖
        // left == 1 && right == 0 左节点有摄像头，右节点无覆盖
        // left == 0 && right == 1 左节点无覆盖，右节点有摄像头
        // left == 0 && right == 2 左节点无覆盖，右节点覆盖
        // left == 2 && right == 0 左节点覆盖，右节点无覆盖
        if (left == 0 || right == 0) {
            result++;
            return 1;
        }

        // 情况3
        // left == 1 && right == 2 左节点有摄像头，右节点有覆盖
        // left == 2 && right == 1 左节点有覆盖，右节点有摄像头
        // left == 1 && right == 1 左右节点都有摄像头
        // 其他情况前面代码均已覆盖
        if (left == 1 || right == 1) {
            return 2;
        }

        // 以上代码我没有使用else，主要是为了把各个分支条件展现出来，这样代码有助于理解
        // 这个 return -1; 逻辑不会走到这里
        return -1;
    }

}

509. 斐波那契数

​​力扣题目链接​​

题目

斐波那契数 （通常用 ​​F(n)​​ 表示）形成的序列称为 斐波那契数列 。该数列由 ​​0​​​ 和 ​​1​​ 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1

给定 ​​n​​​ ，请计算 ​​F(n)​​ 。

示例 1：

输入：n = 2
输出：1
解释：F(2) = F(1) + F(0) = 1 + 0 = 1

示例 2：

输入：n = 3
输出：2
解释：F(3) = F(2) + F(1) = 1 + 1 = 2

示例 3：

输入：n = 4
输出：3
解释：F(4) = F(3) + F(2) = 2 + 1 = 3

提示：

0 <= n <= 30

思路

动规五部曲：

这里我们要用一个一维dp数组来保存递归的结果

1. 确定dp数组以及下标的含义

dp[i]的定义为：第i个数的斐波那契数值是dp[i]

1. 确定递推公式

为什么这是一道非常简单的入门题目呢？

因为题目已经把递推公式直接给我们了：状态转移方程 dp[i] = dp[i - 1] + dp[i - 2];

1. dp数组如何初始化

题目中把如何初始化也直接给我们了，如下：

dp[0] = 0;
dp[1] = 1;

1. 确定遍历顺序

从递归公式 ​​dp[i] = dp[i - 1] + dp[i - 2];​​ 中可以看出，dp[i]是依赖 dp[i - 1] 和 dp[i - 2]，那么遍历的顺序一定是从前到后遍历的

1. 举例推导dp数组

按照这个递推公式dp[i] = dp[i - 1] + dp[i - 2]，我们来推导一下，当N为10的时候，dp数组应该是如下的数列：

0 1 1 2 3 5 8 13 21 34 55

代码实现

/**
 * https://leetcode-cn.com/problems/fibonacci-number/
 *
 * @author xiexu
 * @create 2022-04-02 20:59
 */
public class _509_斐波那契数 {

    public int fib(int n) {
        if (n <= 1) {
            return n;
        }
        int[] dp = new int[n + 1];
        dp[0] = 0;
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }

}

70. 爬楼梯

​​力扣题目链接​​

题目

假设你正在爬楼梯。需要 ​​n​​ 阶你才能到达楼顶。

每次你可以爬 ​​1​​​ 或 ​​2​​ 个台阶。你有多少种不同的方法可以爬到楼顶呢？

示例 1：

输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2

示例 2：

输入：n = 3
输出：3
解释：有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1

提示：

1 <= n <= 45

思路

动规五部曲：

定义一个一维数组来记录不同楼层的状态

1. 确定dp数组以及下标的含义

dp[i]的定义： 爬到第i层楼梯，有dp[i]种方法

1. 确定递推公式

从dp[i]的定义可以看出，dp[i] 可以有两个方向推出来。

首先是dp[i - 1]，上i-1层楼梯，有dp[i - 1]种方法，那么再一步跳一个台阶不就是dp[i]了么。

还有就是dp[i - 2]，上i-2层楼梯，有dp[i - 2]种方法，那么再一步跳两个台阶不就是dp[i]了么。

那么dp[i]就是 dp[i - 1]与dp[i - 2]之和！

所以dp[i] = dp[i - 1] + dp[i - 2] 。

1. dp数组如何初始化

dp[1] = 1;
dp[2] = 2;

1. 确定遍历顺序

从递推公式dp[i] = dp[i - 1] + dp[i - 2]; 中可以看出，遍历顺序一定是从前向后遍历的

1. 举例推导dp数组

举例当n为5的时候，dp table（dp数组）应该是这样的：

代码实现

/**
 * https://leetcode-cn.com/problems/climbing-stairs/
 *
 * @author xiexu
 * @create 2022-04-02 21:04
 */
public class _70_爬楼梯 {

    public int climbStairs(int n) {
        if (n <= 1) {
            return n;
        }
        int[] dp = new int[n + 1];
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) { // 注意i是从3开始的
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }

}

746. 使用最小花费爬楼梯

​​力扣题目链接​​

题目

给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。

你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。

请你计算并返回达到楼梯顶部的最低花费。

示例 1：

输入：cost = [10,15,20]
输出：15
解释：你将从下标为 1 的台阶开始。
- 支付 15 ，向上爬两个台阶，到达楼梯顶部。
总花费为 15

示例 2：

输入：cost = [1,100,1,1,1,100,1,1,100,1]
输出：6
解释：你将从下标为 0 的台阶开始。
- 支付 1 ，向上爬两个台阶，到达下标为 2 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 4 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 6 的台阶。
- 支付 1 ，向上爬一个台阶，到达下标为 7 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 9 的台阶。
- 支付 1 ，向上爬一个台阶，到达楼梯顶部。
总花费为 6

提示：

2 <= cost.length <= 1000
0 <= cost[i] <= 999

思路

这道题是爬楼梯那道题的变种，这里的每一级楼梯都是有价格的，想要跨过它，就要交保护费，而我们每次可以从前一个楼梯或者前两个楼梯爬上来，所以，不难写出动态规划方程：

• 状态定义：​​dp[i]​​​ 表示到达第​​i​​ 级楼梯所需要的最小代价（注意：是到达，还没有跨过）。
• 转移方程：​​dp[i] = Min(dp[i-2]+cost[i-2], dp[i-1]+cost[i-1])​​​，要想到达​​i​​​，要么交​​i-2​​​ 的保护费走两步上来，要么交​​i-1​​ 的保护费走一步上来。
• 初始值：​​dp[0] = dp[1] = 0​​​，可以直接从​​0​​​ 或​​1​​ 号楼梯开始，所以到达它们不需要花费代价。
• 返回值：​​dp[n]​​​，表示到达第​​n​​​ 级楼梯的最小代价，也就是跨过第​​n-1​​ 的最小代价。

代码实现

/**
 * https://leetcode-cn.com/problems/min-cost-climbing-stairs/
 *
 * @author xiexu
 * @create 2022-04-02 21:15
 */
public class _746_使用最小花费爬楼梯 {

    public int minCostClimbingStairs(int[] cost) {
        if (cost.length <= 1) {
            return 0;
        }
        int n = cost.length;
        int[] dp = new int[n + 1];
        dp[0] = 0;
        dp[1] = 0;
        for (int i = 2; i <= n; i++) {
            dp[i] = Math.min(dp[i - 2] + cost[i - 2], dp[i - 1] + cost[i - 1]);
        }
        return dp[n];
    }

}

62. 不同路径

​​力扣题目链接​​

题目

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

示例 1：

输入：m = 3, n = 7
输出：28

示例 2：

输入：m = 3, n = 2
输出：3
解释：
从左上角开始，总共有 3 条路径可以到达右下角。
1. 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右
3. 向下 -> 向右 ->

示例 3：

输入：m = 7, n = 3
输出：28

示例 4：

输入：m = 3, n = 3
输出：6

提示：

1 <= m, n <= 100
题目数据保证答案小于等于 2 * 109

思路

机器人从 (0 , 0) 位置出发，到 (m - 1, n - 1) 终点。

按照动规五部曲来分析：

1. 确定dp数组（dp table）以及下标的含义

dp[i][j] ：表示从（0,0）出发，到(i, j) 有 dp[i][j] 条不同的路径。

1. 确定递推公式

想要求 dp[i][j]，只能有两个方向来推导出来，即dp[i - 1][j] 和 dp[i][j - 1]。

此时再回顾一下 dp[i - 1][j] 表示啥，是从(0, 0)的位置到(i - 1, j)有几条路径，dp[i][j - 1]同理。

那么很自然，​​dp[i][j] = dp[i - 1][j] + dp[i][j - 1]​​​，因为 ​​dp[i][j]​​ 只能从这两个方向过来。

1. dp数组的初始化

如何初始化呢，首先 dp[i][0] 一定都是1，因为从 (0, 0) 的位置到 (i, 0) 的路径只有一条，那么dp[0][j]也同理。

所以初始化代码为：

for (int i = 0; i < m; i++) {
            dp[i][0] = 1;
        }

        for (int i = 0; i < n; i++) {
            dp[0][i] = 1;
        }

1. 确定遍历顺序

这里要看一下递归公式 ​​dp[i][j] = dp[i - 1][j] + dp[i][j - 1]​​，dp[i][j] 都是从其上方和左方推导而来，那么从左到右一层一层遍历就可以了。

这样就可以保证推导 dp[i][j] 的时候，dp[i - 1][j] 和 dp[i][j - 1]一定是有数值的。

1. 举例推导dp数组

代码实现

/**
 * https://leetcode-cn.com/problems/unique-paths/
 *
 * @author xiexu
 * @create 2022-04-02 21:49
 */
public class _62_不同路径 {

    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n];
        for (int i = 0; i < m; i++) {
            dp[i][0] = 1;
        }
        for (int i = 0; i < n; i++) {
            dp[0][i] = 1;
        }

        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];
    }

}

63. 不同路径 II

​​力扣题目链接​​

题目

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。

现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

网格中的障碍物和空位置分别用 1 和 0 来表示。

示例 1：

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

示例 2：

输入：obstacleGrid = [[0,1],[0,0]]
输出：1

提示：

m == obstacleGrid.length
n == obstacleGrid[i].length
1 <= m, n <= 100
obstacleGrid[i][j] 为 0 或 1

思路

动规五部曲：

1. 确定dp数组（dp table）以及下标的含义

dp[i][j] ：表示从（0,0）出发，到(i, j) 有dp[i][j]条不同的路径。

1. 确定递推公式

递推公式和 62.不同路径一样，dp[i][j] = dp[i - 1][j] + dp[i][j - 1]。

但这里需要注意一点，因为有了障碍，(i, j)如果就是障碍的话应该保持初始状态（初始状态为0）。

1. dp数组如何初始化

for (int i = 0; i < m; i++) {
            if (obstacleGrid[i][0] == 1) {
                break;
            }
            dp[i][0] = 1;
        }

        for (int i = 0; i < n; i++) {
            if (obstacleGrid[0][i] == 1) {
                break;
            }
            dp[0][i] = 1;
        }

1. 确定遍历顺序

从递归公式​​dp[i][j] = dp[i - 1][j] + dp[i][j - 1]​​ 中可以看出，一定是从左到右一层一层遍历，这样保证推导dp[i][j]的时候，dp[i - 1][j] 和 dp[i][j - 1]一定是有数值。

1. 举例推导dp数组

• 拿示例1来举例如题：

• 对应的 dp table 如图：

代码实现

/**
 * https://leetcode-cn.com/problems/unique-paths-ii/
 *
 * @author xiexu
 * @create 2022-04-02 22:55
 */
public class _63_不同路径_II {

    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        int[][] dp = new int[m][n];

        for (int i = 0; i < m; i++) {
            if (obstacleGrid[i][0] == 1) {
                break;
            }
            dp[i][0] = 1;
        }

        for (int i = 0; i < n; i++) {
            if (obstacleGrid[0][i] == 1) {
                break;
            }
            dp[0][i] = 1;
        }

        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (obstacleGrid[i][j] == 1) {
                    continue;
                }
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }

        return dp[m - 1][n - 1];
    }

}

343. 整数拆分

​​力扣题目链接​​

题目

给定一个正整数 ​​n​​​ ，将其拆分为 ​​k​​ 个 正整数 的和（ ​​k >= 2​​ ），并使这些整数的乘积最大化。

返回 你可以获得的最大乘积 。

示例 1:

输入: n = 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1。

示例 2:

输入: n = 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。

提示:

2 <= n <= 58

思路

动规五部曲，分析如下：

1. 确定dp数组（dp table）以及下标的含义

dp[i]：分拆数字 ​​i​​​，可以得到的最大乘积为 ​​dp[i]​​。

dp[i]的定义将贯彻整个解题过程，下面哪一步想不懂了，就想想dp[i]究竟表示的是啥！

1. 确定递推公式

可以想 dp[i]最大乘积是怎么得到的呢？

其实可以从1遍历 j，然后有两种渠道得到 dp[i]。

• 一个是​​j * (i - j)​​ 直接相乘。
• 一个是​​j * dp[i - j]​​​，相当于是拆分​​(i - j)​​，对这个拆分不理解的话，可以回想dp数组的定义。

j怎么就不拆分呢？

j是从1开始遍历，拆分j的情况，在遍历j的过程中其实都计算过了。那么从 1 遍历 j，比较 ​​(i - j) * j​​​ 和 ​​dp[i - j] * j​​​ 取最大的。递推公式：​​dp[i] = Max(dp[i], Max((i - j) * j, dp[i - j] * j))​​;

也可以这么理解，​​j * (i - j)​​​ 是单纯的把整数拆分为两个数相乘，而 ​​j * dp[i - j]​​ 是拆分成两个及两个以上的个数相乘。

如果定义 ​​dp[i - j] * dp[j]​​ 也是默认将一个数强制拆成4份及4份以上了。

所以递推公式：​​dp[i] = max({dp[i], (i - j) * j, dp[i - j] * j});​​

那么在取最大值的时候，为什么还要比较dp[i]呢？

因为在递推公式推导的过程中，每次计算dp[i]，取最大的而已。

1. dp的初始化

这里我只初始化dp[2] = 1，从dp[i]的定义来说，拆分数字2，得到的最大乘积是1，这个没有任何异议！

1. 确定遍历顺序

确定遍历顺序，先来看看递归公式：​​dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));​​

dp[i] 是依靠 dp[i - j]的状态，所以遍历i一定是从前向后遍历，先有dp[i - j]再有dp[i]。

枚举j的时候，是从1开始的。i是从3开始，这样dp[i - j]就是dp[2]正好可以通过我们初始化的数值求出来。

所以遍历顺序为：

for (int i = 3; i <= n; i++) {
            for (int j = 1; j <= i - 1; j++) {
                dp[i] = Math.max(dp[i], Math.max(j * (i - j), j * dp[i - j]));
            }
        }

1. 举例推导dp数组

举例当n为10 的时候，dp数组里的数值，如下：

代码实现

/**
 * https://leetcode-cn.com/problems/integer-break/
 *
 * @author xiexu
 * @create 2022-04-02 23:02
 */
public class _343_整数拆分 {

    public int integerBreak(int n) {
        int[] dp = new int[n + 1];
        dp[2] = 1;
        for (int i = 3; i <= n; i++) {
            for (int j = 1; j <= i - 1; j++) {
                dp[i] = Math.max(dp[i], Math.max(j * (i - j), j * dp[i - j]));
            }
        }
        return dp[n];
    }

}

96. 不同的二叉搜索树

​​力扣题目链接​​

题目

给你一个整数 ​​n​​​ ，求恰由 ​​n​​​ 个节点组成且节点值从 ​​1​​​ 到 ​​n​​ 互不相同的 二叉搜索树 有多少种？返回满足题意的二叉搜索树的种数。

示例 1：

输入：n = 3
输出：5

示例 2：

输入：n = 1
输出：1

提示：

1 <= n <= 19

思路

• n为1的时候有一棵树，n为2有两棵树，这个是很直观的

• 来看看n为3的时候，有哪几种情况。

当1为头结点的时候，其右子树有两个节点，看这两个节点的布局，是不是和 n 为2的时候两棵树的布局是一样的啊！

当3为头结点的时候，其左子树有两个节点，看这两个节点的布局，是不是和n为2的时候两棵树的布局也是一样的啊！

当2为头结点的时候，其左右子树都只有一个节点，布局是不是和n为1的时候只有一棵树的布局也是一样的啊！

发现到这里，其实我们就找到了重叠子问题了，其实也就是发现可以通过dp[1] 和 dp[2] 来推导出来dp[3]的某种方式。

dp[3]，就是 元素1为头结点搜索树的数量 + 元素2为头结点搜索树的数量 + 元素3为头结点搜索树的数量

元素1为头结点搜索树的数量 = 右子树有2个元素的搜索树数量 * 左子树有0个元素的搜索树数量

元素2为头结点搜索树的数量 = 右子树有1个元素的搜索树数量 * 左子树有1个元素的搜索树数量

元素3为头结点搜索树的数量 = 右子树有0个元素的搜索树数量 * 左子树有2个元素的搜索树数量

有2个元素的搜索树数量就是dp[2]。

有1个元素的搜索树数量就是dp[1]。

有0个元素的搜索树数量就是dp[0]。

所以​​dp[3] = dp[0] * dp[2] + dp[1] * dp[1] + dp[2] * dp[0]​​

此时我们已经找到递推关系了，那么可以用动规五部曲再系统分析一遍。

动规五部曲：

1. 确定dp数组（dp table）以及下标的含义

dp[i] ： 1到i为节点组成的二叉搜索树的个数为dp[i]。

以下分析如果想不清楚，就来回想一下dp[i]的定义

1. 确定递推公式

在上面的分析中，其实已经看出其递推关系， ​​dp[i] += dp[以j为头结点左子树节点数量] * dp[以j为头结点右子树节点数量]​​

j相当于是头结点的元素，从1遍历到i为止。

所以递推公式：​​dp[i] += dp[j - 1] * dp[i - j];​​​ ，​​j-1​​​ 为j为头结点左子树节点数量，​​i-j​​ 为以j为头结点右子树节点数量

1. dp数组如何初始化

初始化，只需要初始化dp[0]就可以了，推导的基础，都是dp[0]。

那么dp[0]应该是多少呢？

从定义上来讲，空节点也是一棵二叉树，也是一棵二叉搜索树，这是可以说得通的。

从递归公式上来讲，dp[以j为头结点左子树节点数量] * dp[以j为头结点右子树节点数量] 中以j为头结点左子树节点数量为0，也需要dp[以j为头结点左子树节点数量] = 1， 否则乘法的结果就都变成0了。

所以初始化dp[0] = 1

1. 确定遍历顺序

首先一定是遍历节点数，从递归公式：​​dp[i] += dp[j - 1] * dp[i - j]​​可以看出，节点数为i的状态是依靠 i之前节点数的状态。

那么遍历i里面每一个数作为头结点的状态，用j来遍历。

for (int i = 2; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                dp[i] += dp[j - 1] * dp[i - j];
            }
        }

1. 举例推导dp数组

n为5时候的dp数组状态如图：

代码实现

/**
 * https://leetcode-cn.com/problems/unique-binary-search-trees/
 *
 * @author xiexu
 * @create 2022-04-03 10:16
 */
public class _96_不同的二叉搜索树 {

    public int numTrees(int n) {
        if (n <= 1) {
            return 1;
        }
        int[] dp = new int[n + 1];
        dp[0] = 1;
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                dp[i] += dp[j - 1] * dp[i - j];
            }
        }
        return dp[n];
    }

}