贪心算法设计与例题

对玛导至昏

已于 2024-04-27 14:23:51 修改

阅读量10

点赞数

文章标签：贪心算法算法

于 2024-03-30 15:52:46 首次发布

本文链接：https://blog.csdn.net/qq_66921072/article/details/137172453

版权

1.柠檬水找零

860. 柠檬水找零 - 力扣（LeetCode）

class Solution 
{
public:
    bool lemonadeChange(vector<int>& bills) 
    {
        int five=0,ten=0;
        for(auto x:bills)
        {
            if(x==5)
            {
                five++;
            }
            else if(x==10)
            {
                if(five==0) return false;
                else
                {
                    five--;
                    ten++;
                } 
            }
            else
            {
                if(ten && five)  //贪心：先把10块的找出去，留着5块的
                {
                    ten--;
                    five--;
                }
                else if(ten==0 && five>=3)
                {
                    five -= 3;
                }
                else return false;
            }
        }
        return true;
    }
};

2.将数组和减半的最少操作次数

2208. 将数组和减半的最少操作次数 - 力扣（LeetCode）

class Solution 
{
public:
    int halveArray(vector<int>& nums) 
    {
        priority_queue<double> heap;
        double sum=0;
        for(auto x:nums)
        {
            heap.push(x);
            sum += x;
        }
        double half = sum/2.0;
        int count=0;
        while(sum>half)
        {
            double t= heap.top()/2.0;
            heap.pop();
            sum -= t;
            count++;
            heap.push(t);
        }
        return count;
    }
};

3.最大数

179. 最大数 - 力扣（LeetCode）

class Solution 
{
public:
    string largestNumber(vector<int>& nums) 
    {
        //优化：把所有数转化为字符串
        vector<string> strs;
        for(int x:nums) strs.push_back(to_string(x));

        //自己的排序方法
        sort(strs.begin(),strs.end(),[](const string& s1,const string s2)
        {
            return s1+s2 > s2+s1;   //若s1+s2 > s2+s1，说明s1要排在s2前面
        });

        //提取结果
        string ret;
        for(auto& s:strs) ret += s;

        //处理前导0
        if(ret[0]=='0') return "0";
        return ret;
    }
};

4.摆动序列

376. 摆动序列 - 力扣（LeetCode）

class Solution 
{
public:
    int wiggleMaxLength(vector<int>& nums) 
    {
        int n=nums.size();
        if(n<=1) return n;

        int ret=0,left=0;
        for(int i=0;i<n-1;i++)
        {
            int right=nums[i+1]-nums[i];
            if(right==0) continue;
            if(right * left <= 0) ret++;
            left=right;
        }
        return ret+1;
    }
};

5.最长连续递增序列

674. 最长连续递增序列 - 力扣（LeetCode）

class Solution 
{
public:
    int findLengthOfLCIS(vector<int>& nums) 
    {
        int len=1;
        int left=0;
        int right=0;
        for(left=0,right=0;right<nums.size()-1;)
        {
            if(nums[right] < nums[right+1])
            {
                right++;
                len=max(len,right-left+1);
            }
            else
            {
                right++;
                left=right;
            }
        }
        return len;
    }
};

6.买卖股票的最佳时机

121. 买卖股票的最佳时机 - 力扣（LeetCode）

class Solution 
{
public:
    int maxProfit(vector<int>& prices) 
    {
        int ret=0;
        int prevmin=INT_MAX;
        for(int i=0;i<prices.size();i++)
        {
            ret=max(ret,prices[i]-prevmin);
            prevmin=min(prevmin,prices[i]);
        }
        return ret;
    }
};

7.买卖股票的最佳时机II

122. 买卖股票的最佳时机 II - 力扣（LeetCode）

class Solution 
{
public:
    int maxProfit(vector<int>& prices) 
    {
        int ret=0;
        int left=0,right=0;
        for(left=0,right=0;right<prices.size()-1;)
        {
            if(prices[right] < prices[right+1])
            {
                right++;
            }
            else
            {
                right++;
                left=right;
            }
            ret += prices[right]-prices[left];
            left=right;
        }
        return ret;
    }
};

8.按身高排序

2418. 按身高排序 - 力扣（LeetCode）

class Solution 
{
public:
    vector<string> sortPeople(vector<string>& names, vector<int>& heights) 
    {
        int n=names.size();
        vector<int> index(n);
        for(int i=0;i<n;i++) index[i]=i;  //下标数组

        sort(index.begin(),index.end(),[&](int i,int j)   //作为数组下标要加&
        {
            return heights[i] > heights[j];   //降序用大于
        });

        vector<string> ret;
        for(int i=0;i<n;i++)
        {
            ret.push_back(names[index[i]]);
        }
        return ret;
    }
};

9.优势洗牌(田忌赛马)

870. 优势洗牌 - 力扣（LeetCode）

class Solution 
{
public:
    vector<int> advantageCount(vector<int>& nums1, vector<int>& nums2) 
    {
        int n=nums1.size();
        //1.排序
        sort(nums1.begin(),nums1.end());
        vector<int> index2(n);
        for(int i=0;i<n;i++) index2[i]=i;
        sort(index2.begin(),index2.end(),[&](int i,int j)  //先根据nums2的大小关系排index
        {
            return nums2[i] < nums2[j];   //排升序
        });

        //2.田忌赛马
        vector<int> ret(n);
        int left=0,right=n-1;
        for(auto x:nums1)
        {
            if(x > nums2[index2[left]])
            {
                ret[index2[left]] = x;
                left++;
            }
            else
            {
                ret[index2[right]] = x;  //放在对面最大的位置上
                right--;
            }
        }
        return ret;
    }
};

10.增减字符串匹配

942. 增减字符串匹配 - 力扣（LeetCode）

class Solution 
{
public:
    vector<int> diStringMatch(string s) 
    {
        int n=s.size();
        vector<int> nums(n+1);
        vector<int> ret;
        for(int i=0;i<=n;i++) nums[i]=i;
        int left=0,right=n;

        for(auto ch:s)
        {
            if(ch=='I') 
            {
                ret.push_back(nums[left]);
                left++;
            }
            else
            {
                ret.push_back(nums[right]);
                right--;
            }
        }
        ret.push_back(nums[left]);
        return ret;
    }
};

11.分发饼干

455. 分发饼干 - 力扣（LeetCode）

class Solution
{
public:
    int findContentChildren(vector<int>& g, vector<int>& s) 
    {
        sort(g.begin(),g.end());
        sort(s.begin(),s.end());
        int count=0,i=0,j=0;
        while(j != s.size())
        {
            if(g[i] <= s[j]) 
            {
                count++;
                i++;
            }
            j++;

            if(count == g.size()) return count;
        }
        return count;
    }
};

12.最优除法

553. 最优除法 - 力扣（LeetCode）

class Solution 
{
public:
    string optimalDivision(vector<int>& nums) 
    {
        string ret;
        string tmp="(";
        int n=nums.size();
        if(n==1) 
        {
            ret=to_string(nums[0]);
        }
        else if(n==2)
        {
            string s1=to_string(nums[0]);
            string s2=to_string(nums[1]);
            ret = s1 + "/" + s2;
        }
        else
        {
            string s0=to_string(nums[0]);
            for(int i=1;i<n;i++)
            {
                tmp += to_string(nums[i]);
                if(i != n-1)
                {
                    tmp += "/";
                }
            }
            tmp += ")";
            ret = s0 + "/" + tmp;
        }
        return ret;
    }
};

13.跳跃游戏II

45. 跳跃游戏 II - 力扣（LeetCode）

class Solution 
{
public:
    int jump(vector<int>& nums) 
    {
        if(nums.size()==1) return 0;
        int left=0,right=0,ret=0,maxpos=0;
        int n=nums.size();
        while(maxpos < n)
        {
            if(maxpos==n-1) break;
            maxpos=0;
            for(int i=left;i<=right;i++)
            {
                maxpos=max(maxpos,i+nums[i]);
            }
            left=right+1;
            right=maxpos;
            ret++;
        }
        return ret;
    }
};

15.加油站

134. 加油站 - 力扣（LeetCode）

class Solution 
{
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) 
    {
        int n=gas.size();
        for(int i=0;i<n;i++)
        {
            int rest=0;
            int step=0;
            for(;step<n;step++)
            {
                int index=(i+step)%n;  //走step步之后的下标
                rest = rest+gas[index]-cost[index];
                if(rest < 0) break;
            }
            if(rest >= 0) return i;
            i = i + step;
        }
        return -1;
    }
};