目录
1. T1005：K次取反后最大化的数组和
T1005：给你一个整数数组 nums 和一个整数 k ，按以下方法修改该数组：
选择某个下标 i 并将 nums[i] 替换为 -nums[i] 。
重复这个过程恰好 k 次。可以多次选择同一个下标 i 。
以这种方式修改数组后，返回数组 可能的最大和 。
提示：
-
1 <= nums.length <= 104
-
-100 <= nums[i] <= 100
-
1 <= k <= 104
S：自己一开始也想到了排序，但没想到要指定规则按照绝对值大小排序；
再有，关于排序规则的指定，C++中的cmp函数和Java中Comparator接口中的compare方法，是不一样的，要留神！
-
C++中的cmp(a, b)函数：a在前，b在后，>表示降序，<表示升序，如：return a > b（或：return b < a） 表示降序
-
注意一点：cmp如果用于sort方法就用上面的写法，用于qsort方法就要用类似下面的写法（a - b）！
-
-
Java中Comparator接口中的compare(o1, o2)方法：return o1 - o2 表示升序，return o2 - o1 表示降序
1.1 解题思路
贪心的思路：
-
局部最优：让绝对值大的负数变为正数，当前数值达到最大，
-
整体最优：整个数组和达到最大。
本题的解题步骤为：
-
第一步：将数组按照绝对值大小从大到小排序，注意要按照绝对值的大小
-
第二步：从前向后遍历，遇到负数将其变为正数，同时K--
-
第三步：如果K还大于0，那么反复转变数值最小的元素，将K用完（并不是真的还剩多少就转变多少次）
-
第四步：求和
1.2 代码实现
C++：
int largestSumAfterKNegations(vector<int>& nums, int k) {
if (nums.size() == 1) return nums[0];
sort(nums.begin(), nums.end(), cmp);
int maxSum = 0;
for (int i = 0; i < nums.size(); ++i) {
if (nums[i] < 0 && k > 0) {
nums[i] *= -1;
--k;
}
}
if (k % 2 == 1) nums[nums.size() - 1] *= -1;
for (int num : nums) maxSum += num;
return maxSum;
}
private:
static bool cmp(int a, int b) {
return abs(a) > abs(b);// 指定按照绝对值大小降序排列【⭐：a在前，b在后，>表示降序，<表示升序】
// return abs(b) > abs(a);// 错
// return abs(b) < abs(a);// 对
}Java：
public int largestSumAfterKNegations(int[] nums, int k) {
if (nums.length == 1) return nums[0];
int res = 0;
// Arrays.sort(nums, (a, b) -> Math.abs(b) - Math.abs(a));//需转化为包装类
nums = IntStream.of(nums)
.boxed()
.sorted((o1, o2) -> Math.abs(o2) - Math.abs(o1))
.mapToInt(Integer::intValue).toArray();
for (int i = 0; i < nums.length; ++i) {
if (k > 0 && nums[i] < 0) {
nums[i] *= -1;
--k;
}
}
if (k % 2 == 1) nums[nums.length - 1] *= -1;
for (int num : nums) res += num;
return res;
}2. T134：加油站
T134：在一条环路上有 n 个加油站，其中第 i 个加油站有汽油 gas[i] 升。
你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。
给定两个整数数组 gas 和 cost ，如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1 。如果存在解，则 保证 它是 唯一 的。
提示:
-
gas.length == n
-
cost.length == n
-
1 <= n <= 105
-
0 <= gas[i], cost[i] <= 104
S：
这题不太好做。。。
看了题解后，本来总结了一句话：如果答案存在的话，那么从哪一站出发去下一站的油能攒到最多的油（如果有多个，那就是最早开始的那一站），哪一站就是答案！——但仔细想想，实际上呢，并不是这样！！！
比如：gas = [3,1,6,1,4]，cost = [3,4,5,1,2]，差值为：[0,-3,1,0,2]，答案为2，而不是4
gas = [3,1,6,1,4]，cost = [3,1,5,4,2]，差值为：[0,0,1,-3,2]，答案为4
-
更确切的说，应该是：在环路上，在哪一站的总存油量最多，就是哪一站，注意是总的累计存油量！
-
通俗地说就是，如果在连续某几站的累计存油量都是正的，那其中的第一站就是答案！
-
2.1 法1、暴力方法【了解即可，超出时间限制】
for循环适合模拟从头到尾的遍历，而while循环适合模拟环形遍历
C++：
int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
for (int i = 0; i < gas.size(); ++i) { // 从第i个油站出发
int rest = gas[i];
rest -= cost[i];
int index = (i + 1) % gas.size();// 🚩个人没想到的关键点
while (rest > 0 && index != i) {
rest += gas[index];
// rest -= cost[index++];// 不能这样，否则迟早索引越界！
rest -= cost[index];
index = (index + 1) % cost.size();
}// 跳出循环意味着：1、要么油用完了（不论有没有回来），2、要么回来了（能回得来油量肯定>=0）
// if (rest >= 0) // 不够（要对应上面两种）
if (rest >= 0 && index == i) return i;
}
return -1;
}Java：
public int canCompleteCircuit(int[] gas, int[] cost) {
// if (gas.length == 1) return 0;// wrong
for (int i = 0; i < gas.length; ++i) {
int rest = gas[i] - cost[i];
int index = (i + 1) % cost.length;
while (rest > 0 && index != i) {
rest += gas[index] - cost[index];
index = (index + 1) % cost.length;
}
if (rest >= 0 && index == i) {
return i;
}
}
return -1;
}-
时间复杂度：O(n^2)
-
空间复杂度：O(1)
2.2 法2、贪心算法（版本一：全局贪心）
直接从全局进行贪心选择，情况如下：
-
情况一：如果gas的总和小于cost总和，那么无论从哪里出发，一定是跑不了一圈的
-
情况二：rest[i] = gas[i]-cost[i]为一天剩下的油，i从0开始计算累加到最后一站，如果累加没有出现负数，说明从0出发，油就没有断过，那么0就是起点。
-
情况三：如果累加的最小值是负数，汽车就要从非0节点出发，从后向前，看哪个节点能这个负数填平，能把这个负数填平的节点就是出发节点。
C++：
int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
int curSum = 0;
int min = INT_MAX;// 🚩从起点出发，油箱里的油量最小值（也就是在最缺油的一站所缺油的数值）
for (int i = 0; i < gas.size(); ++i) {
int rest = gas[i] - cost[i];
curSum += rest;
if (curSum < min) {
// min = rest;// self
min = curSum;
}
}
if (curSum < 0) return -1;// 无论从哪里出发都不能环行一圈
if (min >= 0) return 0;
for (int i = cost.size() - 1; i >= 0; --i) {
int rest = gas[i] - cost[i];
// curSum += rest;
min += rest;
if (min >= 0) {// 补偿完毕
return i;
}
}
return -1;
}Java：
public int canCompleteCircuit(int[] gas, int[] cost) {
int sum = 0;
int min = Integer.MAX_VALUE;
for (int i = 0; i < gas.length; ++i) {
sum += gas[i] - cost[i];
if (sum < min) {
min = sum;
}
}
if (sum < 0) return -1;
if (min >= 0) return 0;
for (int i = cost.length - 1; i >= 0; --i) {
min += gas[i] - cost[i];
if (min >= 0) return i;
}
return -1;
}-
时间复杂度：$O(n)$
-
空间复杂度：$O(1)$
2.3 贪心算法（版本二）
可以换一个思路，首先如果总油量减去总消耗大于等于零那么一定可以跑完一圈，说明 各个站点的加油站 剩油量rest[i]相加一定是大于等于零的。
每个加油站的剩余量rest[i]为gas[i] - cost[i]。
i从0开始累加rest[i]，和记为curSum，一旦curSum小于零，说明[0, i]区间都不能作为起始位置，起始位置从i+1算起，再从0计算curSum。
为什么一旦[i，j] 区间和为负数，起始位置就可以是j+1呢，j+1后面就不会出现更大的负数？
如果出现更大的负数，就是更新j，那么起始位置又变成新的j+1了。
而且j之前出现了多少负数，j后面就会出现多少正数，因为耗油总和是大于零的（前提我们已经确定了一定可以跑完全程）。
那么
-
局部最优：当前累加rest[j]的和curSum一旦小于0，起始位置至少要是j+1，因为从j开始一定不行。
-
全局最优：找到可以跑一圈的起始位置。
C++：
int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
int start = 0;
int curSum = 0, totalSum = 0;
for (int i = 0; i < cost.size(); ++i) {
curSum += gas[i] - cost[i];
totalSum += gas[i] - cost[i];
if (curSum < 0) {
start = i + 1;
curSum = 0;
}
}
if (totalSum < 0) return -1;
return start;
}Java：
public int canCompleteCircuit(int[] gas, int[] cost) {
int totalSum = 0, curSum = 0;
int start = 0;
for (int i = 0; i < gas.length; ++i) {
totalSum += gas[i] - cost[i];
curSum += gas[i] - cost[i];
if (curSum < 0) {
start = i + 1;
curSum = 0;
}
}
if (totalSum < 0) return -1;
return start;
}-
时间复杂度：$O(n)$
-
空间复杂度：$O(1)$
3. T135：分发糖果【🚩容易误解题意】
T135：n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。
你需要按照以下要求，给这些孩子分发糖果：
-
每个孩子至少分配到 1 个糖果。
-
相邻两个孩子评分更高的孩子会获得更多的糖果。
请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。
提示：
-
n == ratings.length
-
1 <= n <= 2 * 104
-
0 <= ratings[i] <= 2 * 104
S：场景看起来是不难，但是自己一做（如下）就错了。。。[1,3,2,2,1] -> 8（答案为7）
int candy(vector<int>& ratings) {
int bonus = 0;
for (int i = 0; i < ratings.size() - 1; ++i) {
if (ratings[i] < ratings[i + 1] || ratings[i] > ratings[i + 1]) {
++bonus;
}
}
return ratings.size() + bonus;
}这道题目一定是要确定一边之后，再确定另一边，例如比较每一个孩子的左边，然后再比较右边，如果两边一起考虑一定会顾此失彼。
🚩两处理解难点
C++：
int candy(vector<int>& ratings) {
int res = 0;
vector<int> candyVec(ratings.size(), 1);
// 从前往后给右孩子奖糖
for (int i = 1; i < ratings.size(); ++i) {
if (ratings[i] > ratings[i - 1]) {
candyVec[i] = candyVec[i - 1] + 1;
}
}
// 1、🚩从后往前给左孩子奖糖
for (int i = ratings.size() - 2; i >= 0; --i) {
if (ratings[i] > ratings[i + 1]) {
candyVec[i] = max((candyVec[i + 1] + 1), candyVec[i]);// 2、🚩
}
}
for (int candy : candyVec) res += candy;
return res;
}Java：
public int candy(int[] ratings) {
int[] candyArr = new int[ratings.length];// 不像vector那样可以赋初始值
candyArr[0] = 1;
for (int i = 1; i < ratings.length; ++i) {
candyArr[i] = 1;
if (ratings[i] > ratings[i - 1]) {
candyArr[i] = candyArr[i - 1] + 1;
}
}
for (int i = ratings.length - 2; i >= 0; --i) {
if (ratings[i] > ratings[i + 1]) {
candyArr[i] = Math.max(candyArr[i], (candyArr[i + 1] + 1));
}
}
int res = 0;
for (int candy : candyArr) res += candy;
return res;
}
1202
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
