打卡(25)贪心集锦

https://leetcode-cn.com/problems/jump-game/
简单贪心
计算当前能到达的最大距离，计算所有满足小于等于最大距离点，是否可以更新最大距离，以此类推到最后一个元素

class Solution {
public:
    bool canJump(vector<int>& nums) {
        int n=nums.size();
        int most=1;
        for(int i=1;i<=n;i++){
            if(i<=most){
                most=max(most,i+nums[i-1]);
                if(most>=n) return true;
            }
        }
        return false;
    }
};

自己的思路，最近有点被动态规划洗脑了。于是我就倒着动态规划了，时间复杂度是一如既往的大。
倒推，看某个点可以到达的所有点之中是否有可以到达最后一个点的点。从后向前推导到第一个元素。

class Solution {
public:
    bool canJump(vector<int>& nums) {
        int n=nums.size();
        int could[100010]={};
        could[n-1]=1;
        for(int i=n-2;i>=0;i--){
            for(int j=1;j<=nums[i];j++){
                int tag=j+i;
                if(could[tag]){
                    could[i]=1;
                    break;
                }
            }
        }
        return could[0]==1;
    }
};

LeetCode名字叫‘大力哥’，喝大力有好身体！giao!

https://leetcode-cn.com/problems/jump-game-ii/

class Solution {
public:
    int jump(vector<int>& nums){
        int n=nums.size();
        int step[100010]={};
        for(int i=n-2;i>=0;i--){
            step[i]=10000;
            for(int j=nums[i];j>=1;j--){
                if(i+j>=n-1){ 
                    step[i]=1;
                    break;
                }
                if(step[i+j]!=-1){
                    step[i]=min(step[i],1+step[i+j]);
                }
            }
            if(step[i]==10000) step[i]=-1;
        }
        return step[0];
    }
};

终究还是动态规划了，等我看下贪心怎么做。

跳跃游戏II
https://leetcode-cn.com/problems/jump-game-ii/
贪心：
一开始没看懂是为什么这样可以的，后来搞明白了，让我来给出数学证明吧：
[a,……,b,……,c,……,d]假设最佳的路线为a->b->c->d，设为最佳路线A：
那么就满足如下的约束条件：
(1)首先，每个A中元素的后继都必然可以到达：
例如:nums[a]+a>=b
(2)其次，每个A中的元素的后继的后继，(假如有的话),必然不可到达。
例如:nums[a]+a<   \, c,注意是严格小于。

那么我们设置边界，边界例如为limit，表示某个区间中的元素能到达的最远位置为limit，则区间[a,b]的边界必然是在哪里呢，必然是出于区间[b,c)中，因为必须要包含b，而必然不能包含c,直接按照最大的区间来放缩，那就假设是这个区间，（足够讨论问题）。边界随着区间的顺次枚举不断更新,这个时候我们发现所有出现的边界的特点都满足：
当前区间的边界必然位于下一个的相邻区间中，这样的话，其实边界的个数，等于路线的步骤数目减去1。为了修正这个1。可以手动加上去，也可以设置0为第一个边界，那么每次遇到边界，数目就++，最终得到的结果就是跳跃的步数。

class Solution {
public:
    int jump(vector<int>& nums){
        int deep=0,n=nums.size();
        int mmax=0,ans=0;
        for(int i=0;i<n-1;i++){
            mmax=max(mmax,nums[i]+i);
            if(deep==i){
                ans++;
                deep=mmax;
            }
        }
        return ans;
    }
};

买卖股票，贪心+最长递增序列
https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/

找到一段最长的递增子序列，用最大值减去最小值，作为这一段的收益，显然可以证明，这样是收益最大的，否则会有中途一个区间的小损失。
例如[1 2 3 4 5 6],1和6收益最大是5，如果分成好几段，就有[1 2][3 4][5 6]可以看到，收益部分就缺少了[2 3][4 5]这些部分，可以得到
结论，只有最大最小相减才是最优解法。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int st=0,end=0;
        int n=prices.size();
        int ans=0;
        for(int i=0;i<n;i++){
            st=prices[i];
            while(i+1<n){
                if(prices[i]<prices[i+1]) i++;
                else break;
            }
            end=prices[i];
            ans+=end-st;
        }
        return ans;
    }
};

https://leetcode-cn.com/problems/gas-station/
最近做的顺风顺水了，不过就是复杂度还是高，虽然能过，毕竟都是一些简单题目。
贪心的精髓在于，找到可以忽略的一些中间过程，直接从下一个可能的解的位置可以计算，节省算力。
就像这个加油站题目，只要模拟一下，然后下一次要从不能到达的第一个点开始接着找，因为已经假定第一个开始的点是净收益大于0的，那么去掉第一个点之后，其他的点更加不可能到达，类似放缩的思想在这里。

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int sum=0;
        int net[10010];//净收益
        int n=gas.size();
        for(int i=0;i<n;i++)
            net[i]=gas[i]-cost[i];
            
        for(int i=0;i<n;i++){
            if(net[i]>=0){
                int j=i;
                int sum=net[i];
                int k=n;
                while(--k){
                    int tag=(++j)%n;
                    sum+=net[tag];
                    if(sum<0) break;
                }
                if(k==0) return i;
                else i=j;
            }
        }
        return -1;
    }
};

单调栈+贪心
https://leetcode-cn.com/problems/remove-duplicate-letters/
从前往后找的时候，如果这个字母之后还会再出现，就可以按照字典序大胆弹出去，否则就不弹出去。

class Solution {
public:
    string removeDuplicateLetters(string s) {
        int vis[26]={},num[26]={};//数组要初始化，否则可能乱码，这个错误还犯。。。
        for (char ch : s)
            num[ch - 'a']++;
        string stk;
        for (char ch : s) {
            if (!vis[ch - 'a']) {
                while (!stk.empty() && stk.back() > ch) {
                    if (num[stk.back() - 'a'] > 0) {
                        vis[stk.back() - 'a'] = 0;
                        stk.pop_back();
                    } else {
                        break;
                    }
                }
                vis[ch - 'a'] = 1;
                stk.push_back(ch);
            }
            num[ch - 'a'] -= 1;
        }
        return stk;
    }
};