代码随想录算法训练营第三十四天|1005.K次取反后最大化的数组和、134. 加油站、135. 分发糖果
代码随想录算法训练营第三十四天|1005.K次取反后最大化的数组和、134. 加油站、135. 分发糖果
K次取反后最大化的数组和
1005.K次取反后最大化的数组和
文章讲解：https://programmercarl.com/1005.K%E6%AC%A1%E5%8F%96%E5%8F%8D%E5%90%8E%E6%9C%80%E5%A4%A7%E5%8C%96%E7%9A%84%E6%95%B0%E7%BB%84%E5%92%8C.html
题目链接：https://leetcode.cn/problems/maximize-sum-of-array-after-k-negations/
视频讲解：https://www.bilibili.com/video/BV138411G7LY/
自己看到题目的第一想法
- 先排序，然后把最小的负数取逆，如果都是正数则把最小的正数取逆
这里有2个场景，负数数量大于等于k，负数数量小于k
- 负数数量大于k时，直接将负数从最小开始取逆就行
- 负数数量小于k时，先把最小的取逆，然后看剩下的k是偶数还是奇数，是偶数直接不变，是奇数则直接取最后一个值做取逆，正数也开始取逆。
按照自己的想法写出来的代码有问题，当负数取反后的值增量小于正数取反就出错了。
public int largestSumAfterKNegations(int[] nums, int k) {
// 1. 先排序，然后把最小的负数取逆，如果都是正数则把最小的正数取逆
// 这里有2个场景，负数数量大于等于k，负数数量小于k
// 负数数量大于k时，直接将负数从最小开始取逆就行
// 负数数量小于k时，先把最小的取逆，然后看剩下的k是偶数还是奇数，是偶数直接不变，是奇数则直接取最后一个值做取逆，正数也开始取逆
Arrays.sort(nums);
int sum = 0;
int limit = k;
for(int i = 0;i < nums.length; i++){
if(limit > 0){
// 当前值小于0时，取逆
if(nums[i] < 0){
sum += -nums[i];
limit--;
}else if(nums[i] > 0){
// 当前值大于0时，看limit的值是否为2的倍数，如果是则直接不变更，处理完之后limit = 0
if(limit % 2 == 0){
sum += nums[i];
}else{
sum += -nums[i];
}
limit = 0;
}else{
sum += nums[i];
limit = 0;
}
}else{
sum += nums[i];
}
}
return sum;
}
看完代码随想录之后的想法
贪心的思想：
- 局部最优：让绝对值大的负数变为正数。
- 局部最优：当所有负数已经转变为正数后k依然大于0，此时只找数值最小的正整数进行反转，当前数值和可以达到最大。
整体逻辑：
- 先将数组按照绝对值进行从大到小排序
- 从前往后遍历，遇到负数将其变为正数，同时k–
- 如果k还大于0，则反复转变数值最小的元素将K用完
- 求和
自己实现过程中遇到哪些困难
排序的方式并没有按照绝对值去排序，没有想到使用贪心。
加油站
134. 加油站
文章讲解：https://programmercarl.com/0134.%E5%8A%A0%E6%B2%B9%E7%AB%99.html
题目链接：https://leetcode.cn/problems/gas-station/
视频讲解：https://www.bilibili.com/video/BV1jA411r7WX/
自己看到题目的第一想法
求出left数组，left数组为gas[i] - cost[i]。
然后使用快慢指针移动，从left中找出一个能累加后的值一直大于0的位置slow位置。
class Solution {
public int canCompleteCircuit(int[] gas, int[] cost) {
// 局部最优：每次走得到的gas[i + 1]-cost[i]都要大于0，全局最优
// 求出cost[i + 1] - gas[i] 的数组，然后找到一个位置，使得从该位置往后累加的值都大于0
if(gas.length == 1){
if(gas[0] < cost[0]){
return -1;
}else{
return 0;
}
}
int[] left = new int[gas.length];
for(int i = 0; i < gas.length; i++){
left[i] = gas[i] - cost[i];
}
// 从left中找出一个能累加后的值一直大于0的位置
//System.out.println(Arrays.toString(left));
int fast = 1;
int slow = 0;
int sum = left[slow];
while(slow != fast){
//System.out.println("slow:" + slow);
//System.out.println("fast:" + fast);
sum += left[fast];
//System.out.println("sum:" + sum);
if(sum < 0 || left[slow] < 0){
slow++;
if(slow == left.length){
break;
}
fast = slow + 1;
sum = left[slow];
}else{
fast++;
}
if(fast == left.length){
fast = 0;
}
}
if(sum >= 0){
return slow;
}else{
return -1;
}
}
}
最终结果超出时间限制。。。。
看完代码随想录之后的想法
我的方法属于暴力方法，超时了。
代码随想录贪心方法一：全局最优思想
- 把情况分成了3种：
- 情况一：如果gas总和小于cost总和，那无论哪里出发都到不了终点
- 情况二：rest[i] = gas[i]-cost[i]为一天剩下的油，i从0开始计算累加到最后一站，如果累加没有出现负数，说明从0出发，油就没有断过，那么0就是起点。
- 情况三：如果累加的最小值是负数（所有的值的最小和），汽车就要从非0节点出发，从后向前，看哪个节点能把这个负数填平，能把这个负数填平的节点就是出发节点。
代码随想录方法二：局部最优
- 全局累加，如果发现全局累加的值小于0的时候，i就i+1开始取值。
- 每个加油站的剩余量rest[i]为gas[i] - cost[i]。
- i从0开始累加rest[i]，和记为curSum，一旦curSum小于零，说明[0, i]区间都不能作为起始位置，因为这个区间选择任何一个位置作为起点，到i这里都会断油，那么起始位置从i+1算起，再从0计算curSum。比如rest数组为 -3 -5 8 -2，这里在计算的时候会直接跳过 -3 -5，从8开始作为i取值
- 那么局部最优：当前累加rest[i]的和curSum一旦小于0，起始位置至少要是i+1，因为从i之前开始一定不行。全局最优：找到可以跑一圈的起始位置。
- 所以这种方法只用一个for循环就能处理完逻辑。
自己实现过程中遇到哪些困难
看完代码随想录写出的答案，这里要注意局部最优的处理逻辑，当前累加rest[i]的和curSum一旦小于0，起始位置至少要是i+1。
public int canCompleteCircuit(int[] gas, int[] cost) {
int totalSum = 0;
int curSum = 0;
int index = 0;
for(int i = 0; i < gas.length; i++){
int rest = gas[i] - cost[i];
totalSum += rest;
curSum += rest;
if(curSum < 0){
index = i + 1;
curSum = 0;
}
}
if(totalSum < 0){
return -1;
}
return index;
}
分发糖果
135. 分发糖果
文章讲解：https://programmercarl.com/0135.%E5%88%86%E5%8F%91%E7%B3%96%E6%9E%9C.html
题目链接：https://leetcode.cn/problems/candy/
视频讲解：https://www.bilibili.com/video/BV1ev4y1r7wN/
自己看到题目的第一想法
看完代码随想录之后的想法
每个小孩既要和左边的进行比较也要和右边的进行比较。
- 双向考虑过于复杂，只先考虑单边的比较。
- 一次只确定一边：
2.1. 如右边小孩比左边小孩得分高的情况 [1,2,2,5,4,3,2] -> [1,2,1,2,1,1,1]；只考虑右边和左边比较的情况（从前向后遍历）
2.2. 处理左边孩子比右边孩子得分高的情况[1,2,2,5,4,3,2]->1,1,1,4,3,2,1
2.3. 此时其实计算左边孩子比右边孩子得分高的情况时，会和2.1计算的结果匹配上，这里就能知道当前节点左右的情况，在计算左边孩子比右边孩子高的情况下，计算candy[i]的时候candy[i] = max(candy[i + 1] + 1,candy[i])。
千万不要两边一起比较
先确定右边评分大于左边的情况（也就是从前向后遍历）
此时局部最优：只要右边评分比左边大，右边的孩子就多一个糖果，全局最优：相邻的孩子中，评分高的右孩子获得比左边孩子更多的糖果
局部最优可以推出全局最优。
如果ratings[i] > ratings[i - 1] 那么[i]的糖 一定要比[i - 1]的糖多一个，所以贪心：candyVec[i] = candyVec[i - 1] + 1
自己实现过程中遇到哪些困难
class Solution {
public int candy(int[] ratings) {
// 每个小孩既要和左边的进行比较也要和右边的进行比较，过于复杂容易两边都考虑出错。
// 这里可以循环2次先确定右边大于左边，得到一个结果集。再确定左边大于右边，确定左边大于右边的时候同时进行计算，得到最终的结果集，然后同时满足遍历的右边大于左边，左边大于右边的条件。
if(ratings.length == 1){
return 1;
}
int[] candy = new int[ratings.length];
// fill逻辑很核心。没写fill没ac出来
Arrays.fill(candy,1);
// 右大于左的逻辑
for(int i = 1; i < ratings.length; i++){
if(ratings[i] > ratings[i - 1]){
candy[i] = candy[i - 1] + 1;
}
}
// 左大于右的逻辑，左大于右的逻辑，需要特别关注下，这里是从后往前遍历
// 为什么要从后往前遍历呢？这里可以实际操作下，左大于右取值得从右边的初始值去取，如果从左边开始取就取不到比较值了。因为 rating[5]与rating[4]的比较 要利用上 rating[5]与rating[6]的比较结果，所以 要从后向前遍历。如果从前向后遍历，rating[5]与rating[4]的比较 就不能用上 rating[5]与rating[6]的比较结果了 。
// 比如[1,5,4,3,2] 5比4大，但是该取什么值？不知道，没有一个基准值
for(int i = ratings.length - 2; i >= 0; i--){
if(ratings[i]> ratings[i + 1]){
candy[i] = Math.max(candy[i + 1] + 1 , candy[i]);
}
}
int sum = 0;
for(int can : candy){
sum += can;
}
return sum;
}
}
今日收获&学习时长
学习时长：3小时以上
今日收获：贪心逻辑太难想到了，3道题目都是看题解和视频才理解的。摸不着套路求解～