力扣刷题day32|738单调递增的数字、714买卖股票的最佳时机含手续费、968监控二叉树
文章目录
-
- 738. 单调递增的数字
-
- 思路
-
- 难点：遍历顺序
- 难点：设置flag
- 714. 买卖股票的最佳时机含手续费
-
- 贪心思路
-
- 难点
- 968. 监控二叉树
-
- 思路
-
- 难点：如何隔两个节点放一个摄像头
738. 单调递增的数字
力扣题目链接
当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。
给定一个整数 n ，返回 小于或等于 n 的最大数字，且数字呈 单调递增 。
示例 1:
输入: n = 10
输出: 9
示例 2:
输入: n = 1234
输出: 1234
示例 3:
输入: n = 332
输出: 299
思路
题目要求：小于等于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));
}
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
示例 2：
输入：prices = [1,3,7,5,10,3], fee = 3
输出：6
贪心思路
如果使用贪心策略，就是最低值买，最高值（如果算上手续费还盈利）就卖。
此时无非就是要找到两个点，买入日期，和卖出日期。
如果使用贪心策略，就是最低值买，最高值（如果算上手续费还盈利）就卖。
难点
当遇到当前的股价减去手续费高于买入价时就可以卖出（只要有获利就卖掉），但是此时的股价不代表着收益最高，即出现一种情况就是, 可能前面的及时能获利，但是不卖掉再最后卖掉可能获利更多，所以可以继续将最小买入值设置为当前股价减去手续费即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;
}
968. 监控二叉树
力扣题目链接
给定一个二叉树，我们在树的节点上安装摄像头。
节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。
计算监控树的所有节点所需的最小摄像头数量。
示例 1：
输入：[0,0,null,0,0]
输出：1
解释：如图所示，一台摄像头足以监控所有节点。
示例 2：
输入：[0,0,null,0,null,0,null,null,0]
输出：2
解释：需要至少两个摄像头来监视树的所有节点。 上图显示了摄像头放置的有效位置之一。
思路
这是很重要的一个线索，摄像头可以覆盖上中下三层，如果把摄像头放在叶子节点上，就浪费的一层的覆盖。
所以把摄像头放在叶子节点的父节点位置，才能充分利用摄像头的覆盖面积。
从下往上看，局部最优：让叶子节点的父节点安摄像头，所用摄像头最少，整体最优：全部摄像头数量所用最少！
大体思路就是从低到上，先给叶子节点父节点放个摄像头，然后隔两个节点放一个摄像头，直至到二叉树头结点。
难点：如何隔两个节点放一个摄像头
每个节点可能有三种状态，分别用三个数字来表示：
- 0：该节点无覆盖
- 1：本节点有摄像头
- 2：本节点有覆盖
空节点的状态只能是有覆盖，这样就可以在叶子节点的父节点放摄像头了
递归三要素
- 递归的函数
int traversal(TreeNode root) {
- 终止条件
if (root == null) return 2;
- 单层处理逻辑
- 情况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 左节点覆盖，右节点无覆盖
有一个孩子没有覆盖，父节点就应该放摄像头。此时摄像头的数量要加一，并且return 1，代表中间节点放摄像头。
if (left == 0 || right == 0) {
result++;
return 1;
}
- 情况3：左右节点至少有一个有摄像头
如果是以下情况，其实就是 左右孩子节点有一个有摄像头了，那么其父节点就应该是2（覆盖的状态）
left == 1 && right == 2 左节点有摄像头，右节点有覆盖
left == 2 && right == 1 左节点有覆盖，右节点有摄像头
left == 1 && right == 1 左右节点都有摄像头
// 左右节点至少有一个有摄像头
if (left == 1 || right == 1) return 2;
- 情况4：头结点没有覆盖
以上都处理完了，递归结束之后，可能头结点 还有一个无覆盖的情
所以递归结束之后，还要判断根节点，如果没有覆盖，result++
// 头结点没有覆盖
if (traversal(root) == 0) {
result++;
}
完整代码：
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;
}