贪心算法的一些题目总结

134.加油站

贪心思路 

分三种情况

1.gas的油量小于cost 那必定失败

2.从0开始得到的结果大于等于0 那0就是答案

3.从0开始得到的结果小于0 那就从后到前找 看哪一个能补齐结果大于等于0 返回此时的i;

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
         int  rest=0;
         int sum=0;
        int min=INT_MAX;
        for(int i =0;i<gas.size();i++)
        { 
            //gas小于cost 不行
            //从0开始满足 0
            //小于0 从后往前找
        rest=gas[i]-cost[i];
          sum+=rest;
            if(sum<min)
            {
                min=sum;
            }
        }
        if(sum<0)
        {
            return -1;
        }
        if(min>=0)
        {
            return 0;
        }
        for(int i=gas.size()-1;i>0;i--)
        {
            rest=gas[i]-cost[i];
            //这里是min
            min+=rest;
            if(min>=0)
            {
                return i;
            }
        }
        return -1;
    }
};

135.分发糖果

两个维度来看，先初始化一个值都等于1数组，右大于左，左大于右（这里要从后向前遍历才对）。

class Solution {
public:
    int candy(vector<int>& ratings) {
        //分两个维度来看 右大于左 左大于右
        //前者从前开始遍历
        //后者从后开始遍历 //
        vector<int> candy(ratings.size(),1);
        //这里i从开始 不是0
        for(int i=1;i<ratings.size();i++)
        {
            // i和i-1
            if(ratings[i]>ratings[i-1])
            {
                candy[i]=candy[i-1]+1;
            }
        }
        //i>=0
        for(int i=ratings.size()-2;i>=0;i--)
        {
             // i和i+1
            if(ratings[i]>ratings[i+1])
            {
                //这里要比较从前开始遍历得到的candy[i]和这里candy[i+1]+1 两者的大小取最大的
                candy[i]=max(candy[i],candy[i+1]+1);
            }
        }
        int result=0;
        for(int i=0;i<candy.size();i++)
        {
            result+=candy[i];
        }
        return result;
    }
};

860.柠檬水找零

遍历数组对5和10进行加减 在20的时候贪心 10和5优先 全是5最后

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

406.根据身高重建队列

贪心 先按身高从大到小排序 再按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>>queue;
        for(int i=0;i<people.size();i++)
        {
            int position=people[i][1];
            queue.insert(queue.begin()+position,people[i]);
        }
        return queue;
    }
};

452.用最少的箭引爆气球

 用一根箭引爆多个重叠的气球，先对整个数组进行排序，将易重叠的区间放在一起，如果起始值大于上一条的终点值，弓箭加一，更新重叠气球的最小右边界。

class Solution {
public:
    int findMinArrowShots(vector<vector<int>>& points) {
        int result=1;
        //排序
        sort(points.begin(),points.end(),[](const vector<int>&a,const vector<int>&b){return a[0]<b[0];});
        for(int i=1;i<points.size();i++)
        {
            //起始大于终点
            if(points[i][0]>points[i-1][1])
            {
                result++;
            }
            else
            {
                //重叠情况
                points[i][1]=min(points[i][1],points[i-1][1]);
            }
        }
        return result;
    }
};

435.无重叠区间

和弓箭射气球差不多  注意的是判断是否重叠是要加个等号 即0，1 和1，2不算重叠 最后用总数量减去重叠区间个数得到五重叠区间个数

class Solution {
public:
    static bool cmp(vector<int>&a,vector<int>&b)
    {
        return a[0]<b[0];
    }
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        int count=1;
        sort(intervals.begin(),intervals.end(),cmp);
        for(int i=1;i<intervals.size();i++)
        {
            //是>=
            if(intervals[i][0]>=intervals[i-1][1])
            {
                count++;
            }
            else{
                intervals[i][1]=min(intervals[i][1],intervals[i-1][1]);
            }
        }
        //相减
        return intervals.size()- count;
    }
};

763.划分字母区间

1.先找出每个字母出现的最后位置（注意方法）

2.更新右边界 找字母最后出现位置较大的

3.如果此时右边界和下标一致 说明这是这个字母最后一次出现了 且边界大于之前的字母边界 此时就可放入result中

class Solution {
public:
    vector<int> partitionLabels(string s) {
        //找每个字母最后出现的位置
        //判断下标和位置是否相等 找到最远字母
        int hash[27]={0};
        for(int i=0;i<s.size();i++)
        {
            hash[s[i]-'a']=i;
        }
        int left=0;
        int right=0;
        vector<int> result;
        for(int i=0;i<s.size();i++)
        {
            right=max(right,hash[s[i]-'a']);
            if(right==i)
            {
                result.push_back(right-left+1);
                left=i+1;
            }
        }
        return result;
    }
};

56.合并区间

先将目标数组的第一个元素放入结果集中，如果右边界大于左边界则重叠，更新右边界，不重叠则直接将剩余元素放入结果集里面。

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
         vector<vector<int>> result;
        if (intervals.size() == 0) return result; // 区间集合为空直接返回
        // 排序的参数使用了lambda表达式
        sort(intervals.begin(), intervals.end(), [](const vector<int>& a, const vector<int>& b){return a[0] < b[0];});
        result.push_back(intervals[0]);
        for(int i=1;i<intervals.size();i++)
        {
            if(result.back()[1]>=intervals[i][0])
            {
                result.back()[1]=max(result.back()[1],intervals[i][1]);
            }
            else{
                result.push_back(intervals[i]);
            }

        }
        return result;
    }
};