代码随想录第34天 | 1005.K次取反后最大化的数组和 、 134. 加油站 、 135. 分发糖果

一、前言

参考文献：代码随想录

今天的主题是贪心算法，主要是思想就是局部最优解到全局最优解，但是没有一个固定的模板。

那就开始今天的刷题之旅吧！

二、K次取反后最大化的数组和

1、my_思路：

以下是我最开始的思路：

（1）首先对数组进行排序;

（2）for循环遍数组,在k次条件下，数组中所有的负数反转成正数，从最小的负数开始；

（3）最后查看k的奇偶性，偶数不变，奇数的话就把nums排序，排序之后再把最小的元素反转即可；

时间复杂度为O(n);

2、整体代码如下：

class Solution {
public:
    int largestSumAfterKNegations(vector<int>& nums, int k) {
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size(); i++) {
            if (k == 0) {
                break;
            }
            if (nums[i] < 0) {
                nums[i] = -nums[i];
                k--;
            } else {
                break;
            }
        }
        if (k % 2 != 0) {
            sort(nums.begin(), nums.end());
            nums[0] = -nums[0];
        }
        int sum = 0;
        for (int i = 0; i < nums.size(); i++) {
            sum += nums[i];
        }
        return sum;
    }
};

然而卡哥的版本是只有一次排序，那就是按数字的绝对数值大小进行排序，时间复杂度一样的为O(nlog(n))，代码如下：

 

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 (k == 0) {
                break;
            }
            if (nums[i] < 0) {
                nums[i] = -nums[i];
                k--;
            }
        }
        if (k % 2 != 0) {
            nums[nums.size() - 1] *= -1;
        }
        int sum = 0;
        for (int i = 0; i < nums.size(); i++) {
            sum += nums[i];
        }
        return sum;
    }
};

二、加油站

1、暴力思路思路：

（1）首先我先介绍一下暴力解法（我自己也没弄太懂）

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        for (int i = 0; i < gas.size(); i++) {
            int fule = gas[i] - cost[i]; // 剩余油量
            int index = (i + 1) % gas.size();
            while (fule > 0 && index != i) {
                fule += gas[index] - cost[index];
                index = (index + 1) % gas.size();
            }
            if (fule >= 0 && index == i) return i;
        }
        return -1;
    }
};

 第一个for循环遍历加油站起始位置，第二个while判断这个加油站做起始位置行不行，不行就继续下一个；但是超时了，过不了。

 

2、贪心思路：

我只能说很巧妙！

（1）定义三个变量：

        // 统计当前的油量和消耗总和
        int sumcur = 0;
        // 统计所有的补充和消耗差
        int sum = 0;
        // 记录起始位置
        int start = 0;

（2）然后遍历，遍历主要有两个要素 一个是查看sumcur是否为负数，

一个是统计所有的油量差。

        for (int i = 0; i < gas.size(); i++) {
            sumcur += gas[i] - cost[i];
            sum += gas[i] - cost[i];
            if (sumcur < 0) {
                start = i + 1;
                sumcur = 0;
            }
            
        }

3、整体代码如下：

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        // 统计当前的油量和消耗总和
        int sumcur = 0;
        // 统计所有的补充和消耗差
        int sum = 0;
        // 记录起始位置
        int start = 0;
        for (int i = 0; i < gas.size(); i++) {
            sumcur += gas[i] - cost[i];
            sum += gas[i] - cost[i];
            if (sumcur < 0) {
                start = i + 1;
                sumcur = 0;
            }
            
        }
        if (sum < 0) return -1;
        return start;
    }
};

四、分发糖果

1、思路：

这分发糖果啊，我看我室友分了好久，我有点怀疑了都。

看完卡哥的视频后，收获很多，最大的核心思想就是——分开治理

（1）创建糖果基础数组（所有孩子的糖果均为1）

      vector<int> candyVec(ratings.size(), 1);

（2）开始从左到右遍历，比较右边的分数比左边高的孩子就在左边孩子高的基础上加一

  for (int i = 1; i < ratings.size(); i++) {
            if (ratings[i] > ratings[i - 1]) {
                candyVec[i] = candyVec[i - 1] + 1;
            }
        }

（3）从右往左遍历， 左边比右边分数高的话就在此基础上加一，但是要与原来的元素进行比较，如果，优先选大的

  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、整体代码如下：

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 + 1] + 1, candyVec[i]);
            }
        }
        int result = 0;
        for (int i : candyVec) result += i;
        return result;
    }
};

今日学习时间：1.5小时

leave message:

 The best of prophrts of the future is the past.

对未来最好的预言是过去。