贪心算法练习day.3

1005.K次取反后最大化的数组和

链接：. - 力扣（LeetCode）

题目描述：

给你一个整数数组 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 <= 104
• -100 <= nums[i] <= 100
• 1 <= k <= 104

思路：

对于取反过程，我们需要有两次贪心，即对于负数和整数，我们要优先对负数进行取反，而对于负数中，我们又需要优先对绝对值最大的数进行取反，假如我们已经把负数进行了全部取反，即我们的数组中全是整数的情况，而我们的K还没有用完，则我们应该对最小的值进行取反

代码实现：

int cmp(int *a, int *b)
{
    return *a - *b;
}
int largestSumAfterKNegations(int* nums, int numsSize, int k) {
    //一次贪心
    qsort(nums,numsSize,sizeof(int),cmp);
    for(int i = 0; i < numsSize; i++)
    {
        if(nums[i] < 0 && k > 0)
        {
            nums[i] = -nums[i];
            k--;
        }
    }
    //二次贪心
    qsort(nums, numsSize,sizeof(int),cmp);
    if(k % 2 == 1)
        nums[0] *= -1;
    int  add = 0;
    for(int i = 0; i < numsSize;i++)
        add += nums[i];
    return add;
}

 

134.加油站

链接：. - 力扣（LeetCode）

题目描述：

在一条环路上有 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 <= 105
• 0 <= gas[i], cost[i] <= 104

思路：

我们对于这个题的思路就是，我们在开往加油站的过程中，油有补充，也有消耗，我们应该最关心的应该就是油箱是剩油还是缺油，即如下图所示

如果我们从下标0出发，无论如何都不可能跑完一圈，因为在下标3的消耗太多，前面剩余的油为4，少于下标3缺少的-6，因此不能从-6之前出发，因此我们可以使用一个变量累加我们每次的剩余油量，当我们发现这个变量的值为负时，就证明它并不能跑完一圈，因此我们要从这个位置的下一个位置重新开始记录（局部最优），最后推出我们的结果（全局最优）

初始化当前加油站剩余汽油量为0，总的汽油量与花费的差值为0，起始加油站索引为0，遍历所有加油站，累加当前加油站剩余汽油量和总的汽油量与花费的差值，如果当前加油站的剩余汽油量小于0，说明无法从当前加油站出发到达下一个加油站，更新起始加油站为下一个加油站，并重置当前加油站剩余汽油量，如果总的汽油量与花费的差值小于0，说明无法绕行一圈，返回-1表示无法绕行一圈，否则，返回起始加油站的索引

代码实现：

int canCompleteCircuit(int* gas, int gasSize, int* cost, int costSize) {
    int cur_sum = 0; // 当前加油站剩余汽油量
    int total_sum = 0; // 总的汽油量与花费的差值
    int start = 0; // 开始加油站的索引

    // 遍历所有加油站
    for(int i = 0; i < gasSize ;i++)
    {
        cur_sum += gas[i] - cost[i]; // 更新当前加油站剩余汽油量
        total_sum += gas[i] - cost[i]; // 更新总的汽油量与花费的差值
        // 如果当前加油站的剩余汽油量小于0，说明无法从当前加油站出发到达下一个加油站
        if(cur_sum < 0)
        {
            start = i+1; // 更新起始加油站为下一个加油站
            cur_sum = 0; // 重置当前加油站剩余汽油量
        }
    }
    // 如果总的汽油量与花费的差值小于0，说明无法绕行一圈
    if(total_sum < 0)
        return -1; // 返回-1表示无法绕行一圈
    return start; // 返回起始加油站的索引
}

135.分发糖果

链接：. - 力扣（LeetCode）

题目描述：

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 * 104
• 0 <= ratings[i] <= 2 * 104

思路：

我们在考虑给小孩分发糖果时，不能进行两边一起比较，需要先确定一边再确定另外一边，先默认所有小孩的糖果都是1，我们可以先确定右边的小孩比左边的小孩得分高的情况（从前向后），然后再确定左边小孩比右边小孩得分高的情况（从后向前），因为这样才能利用我们上一次比较的结果，否则就会出现矛盾，即右边分高的情况，再和前者进行比较取出一个最大值

代码实现：

int candy(int* ratings, int ratingsSize) {
    // 为每个孩子分配糖果的数组
    int *candynum = (int *)malloc(sizeof(int) * ratingsSize);
    // 初始化每个孩子都分配一个糖果
    for(int i = 0; i < ratingsSize ; i++)
        candynum[i] = 1;

    // 从左向右遍历，如果右边的孩子评分高，分配的糖果数目要比左边的多
    for(int i = 1; i < ratingsSize; i++)
    {
        if(ratings[i] > ratings[i-1])
        {
            candynum[i] = candynum[i-1] + 1; // 比左边孩子多一个糖果
        }
    }

    // 从右向左遍历，如果左边的孩子评分高，分配的糖果数目要比右边的多
    for(int i = ratingsSize -2; i >= 0; i--)
    {
        if(ratings[i] > ratings[i+1])
        {
            candynum[i] = candynum[i] > candynum[i+1] +1 ? candynum[i] : candynum[i+1] + 1; // 取左右两边糖果数目的较大值
        }
    }
    
    // 统计总的糖果数目
    int result = 0;
    for(int i = 0; i < ratingsSize ; i++)
        result += candynum[i];

    return result;
}