力扣刷题day32|738单调递增的数字、714买卖股票的最佳时机含手续费、968监控二叉树

738. 单调递增的数字

力扣题目链接

当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。

给定一个整数 n ，返回 小于或等于 n 的最大数字，且数字呈 单调递增 。

示例 1:

输入: n = 10
输出: 9
1
2

示例 2:

输入: n = 1234
输出: 1234
1
2

示例 3:

输入: n = 332
输出: 299
1
2

思路

题目要求：小于等于N的最大单调递增的整数

一旦出现strNum[i - 1] > strNum[i]的情况（非单调递增），首先想让strNum[i - 1]–，然后strNum[i]给为9，这样就能保证高位变小的情况下低位最大

局部最优：遇到strNum[i - 1] > strNum[i]的情况，让strNum[i - 1]–，然后strNum[i]给为9，可以保证这两位变成最大单调递增整数。

全局最优：得到小于等于N的最大单调递增的整数。

难点：遍历顺序

从前向后遍历的话，遇到strNum[i - 1] > strNum[i]的情况，让strNum[i - 1]减一，但此时如果strNum[i - 1]减一了，可能又小于strNum[i - 2]。

所以应该从后往前遍历

难点：设置flag

对于例子[1, 2, 8, 3, 5, 4]来说

当我们每遇到nums[i - 1] > nums[i]时，就给nums[i]赋值为9

如上图得到数为[1, 2, 7, 9, 4, 9]，显然不是能取到的最大的数

但是如果设置flag之后将flag后的数全部统一赋值，那就能得到最大的值，如下图所示

java中的语句integer.parseint())是将整型数据Integer转换为基本数据类型int

完整代码：

public int monotoneIncreasingDigits(int n) {
    // 将n转为char数组
    String s = String.valueOf(n);
    char[] nums = s.toCharArray();

    // flag用来标记赋值9从哪里开始
    // 设置为这个默认值，为了防止第二个for循环在flag没有被赋值的情况下执行
    int flag = nums.length;
    for (int i = nums.length - 1; i > 0; i--) {
        if (nums[i - 1] > nums[i]) {
            nums[i - 1]--;
            flag = i;
        }
    }
    for (int i = flag; i < nums.length; i++) {
        nums[i] = '9';
    }
    return Integer.parseInt(String.valueOf(nums));
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

714. 买卖股票的最佳时机含手续费

力扣题目链接

给定一个整数数组 prices，其中 prices[i]表示第 i 天的股票价格 ；整数 fee 代表了交易股票的手续费用。

你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。

返回获得利润的最大值。

**注意：**这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。

示例 1：

输入：prices = [1, 3, 2, 8, 4, 9], fee = 2
输出：8
解释：能够达到的最大利润:  
在此处买入 prices[0] = 1
在此处卖出 prices[3] = 8
在此处买入 prices[4] = 4
在此处卖出 prices[5] = 9
总利润: ((8 - 1) - 2) + ((9 - 4) - 2) = 8
1
2
3
4
5
6
7
8

示例 2：

输入：prices = [1,3,7,5,10,3], fee = 3
输出：6
1
2

贪心思路

如果使用贪心策略，就是最低值买，最高值（如果算上手续费还盈利）就卖。

此时无非就是要找到两个点，买入日期，和卖出日期。

如果使用贪心策略，就是最低值买，最高值（如果算上手续费还盈利）就卖。

难点

当遇到当前的股价减去手续费高于买入价时就可以卖出（只要有获利就卖掉），但是此时的股价不代表着收益最高，即出现一种情况就是, 可能前面的及时能获利，但是不卖掉再最后卖掉可能获利更多，所以可以继续将最小买入值设置为当前股价减去手续费即minIn = prices[i] - fee

这样赋值可以保证如果后面有出现更大的获利, 不用减去两次手续费导致结果错误

完整代码：

public int maxProfit(int[] prices, int fee) {
    int res = 0;
    int minIn = prices[0]; // 记录最低买入价
    for (int i = 1; i < prices.length; i++) {
        // 如果有更低的买入价那就在更低价的时候买
        if (prices[i] < minIn) {
            minIn = prices[i];
        }
        // 如果碰到高价，但是卖出没利润，就持仓
        if (prices[i] >= minIn && prices[i] <= minIn + fee) {
            continue;
        }

        // 有利润时
        if (prices[i] > minIn + fee) {
            res += prices[i] -  minIn - fee;
            // 后面还有利润，现在先不急着卖
            // 这样赋值可以保证如果后面有出现更大的获利, 不用减去两次手续费导致结果错误
            minIn = prices[i] - fee;
        }
    }

    return res;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

968. 监控二叉树

力扣题目链接

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

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

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

示例 1：

输入：[0,0,null,0,0]
输出：1
解释：如图所示，一台摄像头足以监控所有节点。
1
2
3

示例 2：

输入：[0,0,null,0,null,0,null,null,0]
输出：2
解释：需要至少两个摄像头来监视树的所有节点。 上图显示了摄像头放置的有效位置之一。
1
2
3

思路

这是很重要的一个线索，摄像头可以覆盖上中下三层，如果把摄像头放在叶子节点上，就浪费的一层的覆盖。

所以把摄像头放在叶子节点的父节点位置，才能充分利用摄像头的覆盖面积。

从下往上看，局部最优：让叶子节点的父节点安摄像头，所用摄像头最少，整体最优：全部摄像头数量所用最少！

大体思路就是从低到上，先给叶子节点父节点放个摄像头，然后隔两个节点放一个摄像头，直至到二叉树头结点。

难点：如何隔两个节点放一个摄像头

每个节点可能有三种状态，分别用三个数字来表示：

• 0：该节点无覆盖
• 1：本节点有摄像头
• 2：本节点有覆盖

空节点的状态只能是有覆盖，这样就可以在叶子节点的父节点放摄像头了

递归三要素

1. 递归的函数

int traversal(TreeNode root) {
1

2. 终止条件

if (root == null) return 2;
1

3. 单层处理逻辑

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

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

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

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

如果是以下情况，则中间节点（父节点）应该放摄像头：

left == 0 && right == 0 左右节点无覆盖

left == 1 && right == 0 左节点有摄像头，右节点无覆盖

left == 0 && right == 1 左节点有无覆盖，右节点摄像头

left == 0 && right == 2 左节点无覆盖，右节点覆盖

left == 2 && right == 0 左节点覆盖，右节点无覆盖

有一个孩子没有覆盖，父节点就应该放摄像头。此时摄像头的数量要加一，并且return 1，代表中间节点放摄像头。

if (left == 0 || right == 0) {
    result++;
    return 1;
}
1
2
3
4

• 情况3：左右节点至少有一个有摄像头

如果是以下情况，其实就是 左右孩子节点有一个有摄像头了，那么其父节点就应该是2（覆盖的状态）

left == 1 && right == 2 左节点有摄像头，右节点有覆盖

left == 2 && right == 1 左节点有覆盖，右节点有摄像头

left == 1 && right == 1 左右节点都有摄像头

// 左右节点至少有一个有摄像头
if (left == 1 || right == 1) return 2;
1
2

• 情况4：头结点没有覆盖

以上都处理完了，递归结束之后，可能头结点 还有一个无覆盖的情

所以递归结束之后，还要判断根节点，如果没有覆盖，result++

// 头结点没有覆盖
if (traversal(root) == 0) { 
    result++;
}
1
2
3
4

完整代码：

public int minCameraCover(TreeNode root) {
    result = 0;
    // 头结点没有覆盖
    if (traversal(root) == 0) {
        result++;
    }
    return result;
}
int result;
int traversal(TreeNode root) {
    if (root == null) return 2;

    int left = traversal(root.left);    // 左
    int right = traversal(root.right);  // 右
    // 单层
    // 左右节点都有覆盖
    if (left == 2 && right == 2) return 0;
    // 左右节点至少有一个无覆盖的情况
    if (left == 0 || right == 0) {
        result++;
        return 1;
    }
    // 左右节点至少有一个有摄像头
    if (left == 1 || right == 1) return 2;

    // 以上代码我没有使用else，主要是为了把各个分支条件展现出来，这样代码有助于读者理解
    // 这个 return -1 逻辑不会走到这里。
    return -1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29