17贪心算法Ⅲ

贪心算法Ⅲ

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

题目描述

给你一个整数数组 nums 和一个整数 k ，按以下方法修改该数组：

• 选择某个下标 i 并将 nums[i] 替换为 -nums[i] 。

重复这个过程恰好 k 次。可以多次选择同一个下标 i 。

以这种方式修改数组后，返回数组 可能的最大和 。

示例 1：

输入：nums = [4,2,3], k = 1
输出：5
解释：选择下标 1 ，nums 变为 [4,-2,3] 。

解题思路

利用贪心算法，反转时优先反转绝对值较大的负数。

若负数反转完k还有剩余，就反转绝对值最小的正数。

要实现该种反转，需要先将nums按照绝对值排序。

代码实现

class Solution {
    static bool cmp(int a,int b)
    {
        return abs(a)>abs(b);
    }
public:
    int largestSumAfterKNegations(vector<int>& nums, int k) {
        sort(nums.begin(),nums.end(),cmp);
        for(int i=0;i<nums.size();i++)
        {
            if(nums[i]<0&&k>0)//优先反转绝对值大的负数
            {
                nums[i]=-nums[i];
                k--;
            }            
        }
        //若负数反转完k还有剩余，就反转绝对值最小的数
        if(k%2==1)nums[nums.size()-1]=-nums[nums.size()-1];
        //计算总和
        int res=0;
        for(int a:nums)//遍历nums中的元素，进行加和。
        res+=a;
        return res;

    }
};

总结

1，绝对值排序的实现，只需要重写sort函数的cmp方法，令cmp返回值按照绝对值较大的判断结果返回。

2，cmp函数返回值要加修饰符static

3，k值还有富裕的时候，因为始终要交换最后一个元素，所以只用判断k的奇偶性即可，若为偶数次交换相当于不处理，若为奇数，则反转一次即可。

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 可为起始索引。

解题思路

方法一：暴力解法，遍历每一个加油站，推演从每一个出发是否能成功返回。该方法在特殊测试用例下，会超时。

方法二：贪心法

首先如果总油量减去总消耗大于等于零那么一定可以跑完一圈，说明 各个站点的加油站 剩油量rest[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开始一定不行。全局最优：找到可以跑一圈的起始位置。

代码实现

(1) 暴力法

用for循环去遍历第i个加油站作为起点站，用while循环去遍历从第i个站出发能不能环形回来，因此while循环条件是index！=i；

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        for(int i=0;i<cost.size();i++)
        {
            int rest=gas[i]-cost[i];
            //每算一个rest代表车走到下一站了，index要=i+1。由于是环形走，因此要到cost.size取余数
            int index=(i+1)%cost.size();
            while(rest>0&&index!=i)//利用while模拟环形遍历，模拟从站i开始走一圈
            {
                rest+=gas[index]-cost[index];
                index=(index+1)%cost.size();//index更新的策略与for循环相同。
            
            }
            if(rest>=0&&index==i)return i;
        }
        return -1;
    }

（2）贪心算法

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
       int cursum=0,totalsum=0,start=0;
       for(int i=0;i<gas.size();i++)
       {
            cursum+=gas[i]-cost[i];
            totalsum+=gas[i]-cost[i];
            if(cursum<0)//当累加值小于0，重置起始位置。
            {
                start=i+1;
                cursum=0;
            }
       }
       if (totalsum<0) return -1;//总的油量小于总需求，说明怎么都走不完。
       return start;//否则，说明能走完，从累加值为正值的start开始走，就能保证rest不为负。
    }
};

总结

1.暴力法需要两层遍历，第一层是遍历第i个加油站作为起点，第二层遍历是从i开始算油耗是否支撑再走回i，环形遍历。while更适合环形遍历，因此第二层用while。

2.贪心算法思路不好想，需要想到能走完全程油耗供给需求差总数应该大于等于0.那么当区间0-i的差额和为负，就说明后面的差额有正值，起点就应该从i+1开始选，这就是贪心的局部最优，追求局部的cursum尽可能为正值，若为负就抛弃重算。

135分发糖果

题目描述

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

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

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

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

示例 1：

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

解题思路

思路一：

两轮遍历。第一轮正序遍历，两两比较，rating大的candy等于小的加1。

第二轮反向遍历。

思路二：两次贪心

• 一次是从左到右遍历，只比较右边孩子评分比左边大的情况。
• 一次是从右到左遍历，只比较左边孩子评分比右边大的情况。

这样从局部最优推出了全局最优，即：相邻的孩子中，评分高的孩子获得更多的糖果。

代码实现

代码一:自己写的

class Solution {
public:
    int candy(vector<int>& ratings) {
        vector<int>candym(ratings.size(),1);
        int res=0;
        for(int i=0;i<ratings.size()-1;i++)
        {
            if(ratings[i]>ratings[i+1])
            {
                candym[i]=candym[i+1]+1;
            }
            else if(ratings[i]<ratings[i+1])
            {
                candym[i+1]=candym[i]+1;
            }
        }
        for(int i=ratings.size()-1;i>0;i--)
        {
            if((ratings[i]>ratings[i-1])&&candym[i]<=candym[i-1])
            {
                candym[i]=candym[i-1]+1;
            }
            else if(ratings[i]<ratings[i-1])
            {
                candym[i-1]=candym[i]+1;
            }
        }
        //统计糖果总数
        for(int a:candym)
        {
            res+=a;
            
        }
        return res;
    }
};

代码二：贪心思路

class Solution {
public:
    int candy(vector<int>& ratings) {
        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;
        }
        // 从后向前
        for (int i = ratings.size() - 2; i >= 0; i--) {
            if (ratings[i] > ratings[i + 1] ) {
                candyVec[i] = max(candyVec[i], candyVec[i + 1] + 1);
            }
        }
        // 统计结果
        int result = 0;
        for (int i = 0; i < candyVec.size(); i++) result += candyVec[i];
        return result;
    }
};