1005. K 次取反后最大化的数组和
给你一个整数数组 nums 和一个整数 k ，按以下方法修改该数组：
- 选择某个下标 i 并将 nums[i] 替换为 -nums[i] 。
重复这个过程恰好 k 次。可以多次选择同一个下标 i 。
以这种方式修改数组后，返回数组 可能的最大和 。
示例 1： 输入：nums = [4,2,3], k = 1 输出：5 解释：选择下标 1 ，nums 变为 [4,-2,3] 。 示例 2： 输入：nums = [3,-1,0,2], k = 3 输出：6 解释：选择下标 (1, 2, 2) ，nums 变为 [3,1,0,2] 。 示例 3： 输入：nums = [2,-3,-1,5,-4], k = 2 输出：13 解释：选择下标 (1, 4) ，nums 变为 [2,3,-1,5,4] 。
思路
把负的全部转正，剩下的看k是奇数就把最小的一个反转，是偶数就不用管直接返回和
题解
class Solution {
public:
// 定义一个函数用于计算向量的和
int sum(vector<int> nums){
int sum = 0;
// 遍历向量中的每个元素并累加到 sum 变量
for(int i : nums){
sum += i;
}
return sum; // 返回总和
}
// 主要函数，接受一个整数向量和一个整数 k 作为参数
int largestSumAfterKNegations(vector<int>& nums, int k) {
// 首先，按升序对向量进行排序，以确保负数位于前面
sort(nums.begin(), nums.end());
// 遍历向量
for(int i = 0; i < nums.size(); i++){
if(k == 0) break; // 如果 k 为 0，停止循环
if(nums[i] < 0){ // 如果当前元素为负数
nums[i] = -nums[i]; // 取反当前元素
k -= 1; // 减少 k 的值
}
else break; // 如果当前元素为正数，停止循环
}
// 再次对向量进行排序，以确保最小的元素位于前面
sort(nums.begin(), nums.end());
// 如果 k 是奇数，将最小的元素取反
if(k % 2 != 0){
nums[0] = -nums[0];
}
// 调用 sum 函数并返回向量的总和
return sum(nums);
}
};
134. 加油站
在一条环路上有 n 个加油站，其中第 i 个加油站有汽油 gas[i] 升。 你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。 给定两个整数数组 gas 和 cost ，如果你可以按顺序绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1 。如果存在解，则 保证 它是 唯一 的。 示例 1: 输入: gas = [1,2,3,4,5], cost = [3,4,5,1,2] 输出: 3 解释: 从 3 号加油站(索引为 3 处)出发，可获得 4 升汽油。此时油箱有 = 0 + 4 = 4 升汽油 开往 4 号加油站，此时油箱有 4 - 1 + 5 = 8 升汽油 开往 0 号加油站，此时油箱有 8 - 2 + 1 = 7 升汽油 开往 1 号加油站，此时油箱有 7 - 3 + 2 = 6 升汽油 开往 2 号加油站，此时油箱有 6 - 4 + 3 = 5 升汽油 开往 3 号加油站，你需要消耗 5 升汽油，正好足够你返回到 3 号加油站。 因此，3 可为起始索引。 示例 2: 输入: gas = [2,3,4], cost = [3,4,3] 输出: -1 解释: 你不能从 0 号或 1 号加油站出发，因为没有足够的汽油可以让你行驶到下一个加油站。 我们从 2 号加油站出发，可以获得 4 升汽油。 此时油箱有 = 0 + 4 = 4 升汽油 开往 0 号加油站，此时油箱有 4 - 3 + 2 = 3 升汽油 开往 1 号加油站，此时油箱有 3 - 3 + 3 = 3 升汽油 你无法返回 2 号加油站，因为返程需要消耗 4 升汽油，但是你的油箱只有 3 升汽油。 因此，无论怎样，你都不可能绕环路行驶一周。
思路
贪心算法的核心思想是在每个阶段都作出在当前看来最好的选择，以达到最终的最优解。
- 选择最佳的起始点:
- 在遍历过程中，一旦发现从当前起始点出发无法到达下一个加油站（即
currentGas为负），便立即将起始点更换为下一个加油站，并重置currentGas。这是一个贪心的选择，它避免了无效的尝试和进一步的模拟，从而节省了计算时间。
- 一次遍历:
- 贪心算法通过单次遍历来检查所有的可能起始点，而不是分别对每个起始点进行模拟。这种方法旨在以最快的速度找到一个可能的解决方案。
- 总汽油量检查:
- 通过计算所有加油站的总汽油量与消耗的差值
totalGas，快速确定是否存在一个可行的解决方案。如果totalGas为负，那么无解；否则，存在解决方案。这种贪心的检查帮助快速确定问题的可解性，避免了不必要的计算。
- 维护当前汽油量:
- 在遍历的过程中，持续更新
currentGas的值，以保证汽车有足够的汽油到达下一个加油站。这种贪心的更新策略旨在确保每个时刻都有最大可能的汽油量，以完成循环。
题解
class Solution {
public:
int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
int totalGas = 0; // 记录总的汽油量
int currentGas = 0; // 记录当前汽油量
int startStation = 0; // 记录起始加油站
// 遍历每个加油站
for(int i = 0; i < gas.size(); ++i) {
totalGas += gas[i] - cost[i]; // 更新总汽油量
currentGas += gas[i] - cost[i]; // 更新当前汽油量
// 如果当前汽油量为负，则不能从当前起始加油站开始，将起始加油站设置为下一个加油站，并重置当前汽油量
if(currentGas < 0) {
startStation = i + 1;
currentGas = 0;
}
}
// 如果总的汽油量为负，则无法完成一圈
if(totalGas < 0) {
return -1;
}
return startStation; // 返回起始加油站
}
};
135. 分发糖果
n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。 你需要按照以下要求，给这些孩子分发糖果：
- 每个孩子至少分配到 1 个糖果。
- 相邻两个孩子评分更高的孩子会获得更多的糖果。
请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。
示例 1： 输入：ratings = [1,0,2] 输出：5 解释：你可以分别给第一个、第二个、第三个孩子分发 2、1、2 颗糖果。 示例 2： 输入：ratings = [1,2,2] 输出：4 解释：你可以分别给第一个、第二个、第三个孩子分发 1、2、1 颗糖果。 第三个孩子只得到 1 颗糖果，这满足题面中的两个条件。
思路
局部最优拓展到全局最优的思想在这道题上的映射是从前往后和从后往前的局部最优合并为全局最优
- 从左到右遍历：首先，从左到右遍历孩子，如果右边的孩子的评分比左边的孩子高，那么右边的孩子应该得到比左边的孩子更多的糖果。
- 从右到左遍历：然后，从右到左遍历孩子，如果左边的孩子的评分比右边的孩子高，且左边的孩子得到的糖果不多于右边的孩子，那么左边的孩子应该得到比右边的孩子更多的糖果。
题解
class Solution {
public:
int candy(vector<int>& ratings) {
int n = ratings.size();
vector<int> candies(n, 1); // 初始化，每个孩子至少得到一颗糖果
// 从左到右遍历
for (int i = 1; i < n; ++i) {
if (ratings[i] > ratings[i - 1]) {
candies[i] = candies[i - 1] + 1; // 如果右边的孩子评分高，分配更多糖果
}
}
// 从右到左遍历
for (int i = n - 2; i >= 0; --i) {
if (ratings[i] > ratings[i + 1] && candies[i] <= candies[i + 1]) {
candies[i] = candies[i + 1] + 1; // 如果左边的孩子评分高且糖果不多于右边的孩子，分配更多糖果
}
}
// 计算总糖果数
int totalCandies = 0;
for (int candy : candies) {
totalCandies += candy;
}
return totalCandies;
}
};
