代码随想录算法训练营第二十六天|134. 加油站、135. 分发糖果、860.柠檬水找零、406.根据身高重建队列

最新推荐文章于 2024-07-14 15:44:19 发布

Winslow_w

最新推荐文章于 2024-07-14 15:44:19 发布

阅读量870

点赞数 28

文章标签：算法

本文链接：https://blog.csdn.net/Winslow_w/article/details/140191652

版权

134. 加油站

在一条环路上有 N 个加油站，其中第 i 个加油站有汽油 gas[i] 升。

你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。

如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1。

贪心算法1：

情况一：如果gas的总和小于cost总和，那么无论从哪里出发，一定是跑不了一圈的
情况二：rest[i] = gas[i]-cost[i]为一天剩下的油，i从0开始计算累加到最后一站，如果累加没有出现负数，说明从0出发，油就没有断过，那么0就是起点。
情况三：如果累加的最小值是负数，汽车就要从非0节点出发，从后向前，看哪个节点能把这个负数填平，能把这个负数填平的节点就是出发节点

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int curSum = 0;
        int min = INT_MAX;
        for(int i=0; i<gas.size(); i++){
            int res = gas[i]-cost[i];
            curSum+=res;
            if(curSum < min){//求一路下来，油量的最低点
                min = curSum;
            }
        }
        if(curSum<0) return -1;//情况1
        if(min>0) return 0;//情况2
        for(int i=gas.size()-1; i>=0; i--){
            int rest = gas[i]-cost[i];
            min+=rest;
            if(min>=0){ //情况3，从后往前遍历，获得油量第一次大于0的节点
                return i;
            }
        }
        return -1;
    }
};

时间复杂度：O(n)
空间复杂度：O(1)

但这不是典型的贪心算法，因为它没有获得局部最优。

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

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

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int curSum=0;
        int totalSum=0;
        int start=0;
        for(int i=0; i<gas.size(); i++){
            curSum += gas[i]-cost[i];
            totalSum += gas[i]-cost[i];
            if(curSum<0){
                start=i+1;
                curSum=0;
            }
        }
        if(totalSum<0) return -1;
        return start;
    }
};

时间复杂度：O(n)
空间复杂度：O(1)

这个想法很难想，但是举不出反例。因为全局最优解是根据局部最优推导出来的，所以实现贪心。

135. 分发糖果

老师想给孩子们分发糖果，有 N 个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分。

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

每个孩子至少分配到 1 个糖果。
相邻的孩子中，评分高的孩子必须获得更多的糖果

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

首先从前往后遍历：右边评分比左边大，右边的孩子就多一个糖：

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

再确定左孩子大于右孩子的情况（从后向前遍历）。定左孩子大于右孩子的情况一定要从后向前遍历。

如果 ratings[i] > ratings[i + 1]，此时candyVec[i]（第i个小孩的糖果数量）就有两个选择了，一个是candyVec[i + 1] + 1（从右边这个加1得到的糖果数量），一个是candyVec[i]（之前比较右孩子大于左孩子得到的糖果数量）。

所以要取两者的更大值，确保局部最优。

class Solution {
public:
    int candy(vector<int>& rating) {
        vector<int> candyvec(rating.size(), 1);
        for(int i=1;i<rating.size(); i++){
            if(rating[i]>rating[i-1]) candyvec[i] = candyvec[i-1]+1;
        }
        for(int i=rating.size()-2; i>=0; i--){
            if(rating[i]>rating[i+1]) candyvec[i] = max(candyvec[i+1]+1, candyvec[i]);
        }
        return accumulate(candyvec.begin(), candyvec.end(), 0);
    }
};

860.柠檬水找零

在柠檬水摊上，每一杯柠檬水的售价为 5 美元。

顾客排队购买你的产品，（按账单 bills 支付的顺序）一次购买一杯。

每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。

局部最优：遇到账单20，优先消耗美元10，完成本次找零。全局最优：完成全部账单的找零。

情况一：账单是5，直接收下。
情况二：账单是10，消耗一个5，增加一个10
情况三：账单是20，优先消耗一个10和一个5，如果不够，再消耗三个5

class Solution {
public:
    bool lemonadeChange(vector<int>& bills) {
        int five=0, ten=0, twenty = 0;
        for(int bill:bills){
            if(bill==5){
                five++;
            }
            if(bill==10){
                if(five>0){
                    five--;
                    ten++;
                }else{
                    return false;
                }
            }
            if(bill==20){
                if(ten>0&&five>0){
                    five--;
                    ten--;
                    twenty++;
                }else if(five>=3){
                    five-=3;
                    twenty++;
                }else{
                    return false;
                }
            }
        }
        return true;
    }
};

时间复杂度: O(n)
空间复杂度: O(1)

406.根据身高重建队列

遇到两个维度权衡的时候，一定要先确定一个维度，再确定另一个维度。

假设身高的维度是h，而排序的维度是k，我们需要先从身高的维度去排序，从大到小。按照k来从小到大排序，排完之后，会发现k的排列并不符合条件，身高也不符合条件。

按照身高排序之后，优先按身高高的people的k来插入，后序插入节点也不会影响前面已经插入的节点，最终按照k的规则完成了队列。

class Solution {
public:
    static bool cmp(vector<int>& a, vector<int>& b){
        if(a[0]==b[0]) return a[1]<b[1];
        return a[0]>b[0];
    }
    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        sort(people.begin(), people.end(), cmp);
        vector<vector<int>> res;
        for(int i=0; i<people.size(); i++){
            res.insert(res.begin()+people[i][1], people[i]);
        }
        return res;
    }
};

时间复杂度：O(nlog n + n^2)
空间复杂度：O(n)

但使用vector（动态数组）来insert，是费时的，插入再拷贝的话，单纯一个插入的操作就是O(n^2)了，甚至可能拷贝好几次，就不止O(n^2)了

所以使用链表list，可以节省时间复杂度：

class Solution {
public:
    static bool cmp(const vector<int>& a, const vector<int>& b){
        if(a[0]==b[0]) return a[1]<b[1];
        return a[0]>b[0];
    }
    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        sort(people.begin(), people.end(), cmp);
        list<vector<int>> que;
        for(int i=0; i<people.size(); i++){
            int position = people[i][1];
            list<vector<int>>::iterator it = que.begin();
            while(position--){
                it++;
            }
            que.insert(it, people[i]);
        }
        return vector<vector<int>>(que.begin(), que.end());
    }
};

时间复杂度：O(nlog n + n^2)
空间复杂度：O(n)

Winslow_w

关注

28
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营第二十六天|134. 加油站、135. 分发糖果、860.柠檬水找零、406.根据身高重建队列

如果 ratings[i] > ratings[i + 1]，此时candyVec[i]（第i个小孩的糖果数量）就有两个选择了，一个是candyVec[i + 1] + 1（从右边这个加1得到的糖果数量），一个是candyVec[i]（之前比较右孩子大于左孩子得到的糖果数量）。i从0开始累加rest[i]，和记为curSum，一旦curSum小于零，说明[0, i]区间都不能作为起始位置，因为这个区间选择任何一个位置作为起点，到i这里都会断油，那么起始位置从i+1算起，再从0计算curSum。
复制链接

扫一扫