0.引言

● 1005.K次取反后最大化的数组和
● 134. 加油站
● 135. 分发糖果

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] 。

提示：

• 1 <= nums.length <= 10<sup>4</sup>
• -100 <= nums[i] <= 100
• 1 <= k <= 10<sup>4</sup>

Discussion | Solution

贪心思想

自己尝试：

/*
 * @lc app=leetcode.cn id=1005 lang=cpp
 *
 * [1005] K 次取反后最大化的数组和
 */

// @lc code=start
class Solution {
 public:
  int largestSumAfterKNegations(vector<int>& nums, int k) {
    std::sort(nums.begin(), nums.end());
    for (int i = 0; i < nums.size() && k > 0; ++i) {
        std::cout << i << ", ";
      if (nums[i] < 0) {
        nums[i] = -nums[i];
        k--;
      } else if (nums[i] == 0) {
        k--;
        i--;
      } else {
        nums[i] = -nums[i];
        k--;
        i--;
      }
    }
    return std::accumulate(nums.begin(), nums.end(), 0);
  }
};
// @lc code=end

有case过不了：

image.png

更正：

/*
 * @lc app=leetcode.cn id=1005 lang=cpp
 *
 * [1005] K 次取反后最大化的数组和
 */

// @lc code=start
class Solution {
 public:
  int largestSumAfterKNegations(vector<int>& nums, int k) {
    std::sort(nums.begin(), nums.end());
    // 分两步骤，先把有负数的情况处理了
    for (int i = 0; i < nums.size() && k > 0; ++i) {
      if (nums[i] < 0) {
        nums[i] = -nums[i];
        k--;
      }
    }
    // 然后再按照最小的一位进行反转
    if (k % 2 == 1) {
      int min_value = *min_element(nums.begin(), nums.end());
      int sum = accumulate(nums.begin(), nums.end(), 0);
      return sum - 2 * min_value;
    }
    return std::accumulate(nums.begin(), nums.end(), 0);
  }
};
// @lc code=end

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 升汽油。
因此，无论怎样，你都不可能绕环路行驶一周。

提示:

• gas.length == n
• cost.length == n
• 1 <= n <= 10<sup>5</sup>
• 0 <= gas[i], cost[i] <= 10<sup>4</sup>

Discussion | Solution

贪心思想

image.png

自己尝试，好像找起点的方法不对：

/*
 * @lc app=leetcode.cn id=134 lang=cpp
 *
 * [134] 加油站
 */

// @lc code=start
class Solution {
 public:
  int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
    int start = find_start(gas, cost);
    if (start < 0) return -1;
    int remain = gas[start];
    for (int i = start + 1; i < gas.size(); ++i) {
      remain = remain + gas[i] - cost[i - 1];
      if (remain < 0) return -1;
    }
    // 0 特殊处理
    remain = remain - gas[0] - cost[cost.size() - 1];
    for (int i = 1; i <= start; ++i) {
      remain = remain + gas[i] - cost[i];
      if (remain < 0) return -1;
    }
    return start;
  }

 private:
  int find_start(std::vector<int>& gas, std::vector<int>& cost) {
    int i = 0;
    int size = gas.size() < cost.size() ? gas.size() : cost.size();
    while (size--) {
      if (gas[i] > cost[i]) {
        return i;
      }
      i++;
    }
    return -1;
  }
};
// @lc code=end

image.png

可以换一个思路，首先如果总油量减去总消耗大于等于零那么一定可以跑完一圈，说明 各个站点的加油站 剩油量rest[i]相加一定是大于等于零的。

每个加油站的剩余量rest[i]为gas[i] - cost[i]。

i从0开始累加rest[i]，和记为curSum，一旦curSum小于零，说明[0, i]区间都不能作为起始位置，因为这个区间选择任何一个位置作为起点，到i这里都会断油，那么起始位置从i+1算起，再从0计算curSum。

如图：

image.png

那么为什么一旦[0，i] 区间和为负数，起始位置就可以是i+1呢，i+1后面就不会出现更大的负数？

如果出现更大的负数，就是更新i，那么起始位置又变成新的i+1了。

那有没有可能 [0，i] 区间 选某一个作为起点，累加到 i这里 curSum是不会小于零呢？ 如图：

如果 curSum<0 说明 区间和1 + 区间和2 < 0， 那么 假设从上图中的位置开始计数curSum不会小于0的话，就是 区间和2>0。

区间和1 + 区间和2 < 0 同时 区间和2>0，只能说明区间和1 < 0， 那么就会从假设的箭头初就开始从新选择其实位置了。

那么局部最优：当前累加rest[i]的和curSum一旦小于0，起始位置至少要是i+1，因为从i之前开始一定不行。全局最优：找到可以跑一圈的起始位置。

局部最优可以推出全局最优，找不出反例，试试贪心！

/*
 * @lc app=leetcode.cn id=134 lang=cpp
 *
 * [134] 加油站
 */

// @lc code=start
class Solution {
 public:
  int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
    int start = 0, total_gas = 0, total_cost = 0, curr_gas = 0;
    // 能否循环看总的油量即可
    // 问题就转换为找start
    for (int i = 0; i < gas.size(); ++i) {
      total_gas += gas[i];
      total_cost += cost[i];
      curr_gas += gas[i] - cost[i];

      if (curr_gas < 0) {
        start = i + 1;
        curr_gas = 0;
      }
    }

    if (total_gas >= total_cost) {
      return start;
    } else {
      return -1;
    }
  }
};
// @lc code=end

135. # 分发糖果

n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。

你需要按照以下要求，给这些孩子分发糖果：

• 每个孩子至少分配到 1 个糖果。
• 相邻两个孩子评分更高的孩子会获得更多的糖果。

请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。

示例 1：

输入：ratings = [1,0,2]
输出：5
解释：你可以分别给第一个、第二个、第三个孩子分发 2、1、2 颗糖果。

示例 2：

输入：ratings = [1,2,2]
输出：4
解释：你可以分别给第一个、第二个、第三个孩子分发 1、2、1 颗糖果。
     第三个孩子只得到 1 颗糖果，这满足题面中的两个条件。

提示：

• n == ratings.length
• 1 <= n <= 2 * 10<sup>4</sup>
• 0 <= ratings[i] <= 2 * 10<sup>4</sup>

Discussion | Solution

贪心思想

• 参考链接

• 这道题目一定是要确定一边之后，再确定另一边，例如比较每一个孩子的左边，然后再比较右边，如果两边一起考虑一定会顾此失彼。

• 先确定右边评分大于左边的情况（也就是从前向后遍历）

• 此时局部最优：只要右边评分比左边大，右边的孩子就多一个糖果，全局最优：相邻的孩子中，评分高的右孩子获得比左边孩子更多的糖果

• 局部最优可以推出全局最优。

/*
 * @lc app=leetcode.cn id=135 lang=cpp
 *
 * [135] 分发糖果
 */

// @lc code=start
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] = max(candies[i], candies[i + 1] + 1);
      }
    }

    int total_candies = 0;
    for (int candy : candies) {
      total_candies += candy;
    }

    return total_candies;
  }
};
// @lc code=end

4.简书什么玩意儿？？

image.png