算法训练营day32_贪心算法（3.4）

算法训练营day32_贪心算法（3.4）

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

刚开始也是审题不清，以为是只能一次买卖；

遍历买当前股票，在跌的前一天卖；

用双指针来走；

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

随想录思路：

构造收益序列（从第二天开始，比天数少一），只收集正向收益；也就是说，只要上升的部分；

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

55.跳跃游戏

dfs往后走，由于可以dfs到相同的位置，所以为了节省时间，采用记忆化搜索；

参数为位置u，数组；返回int（1表示可以到终点，0表示不可以到终点，-1表示还没到）；

之前到过，直接返回；到达终点（注意这里是u>=size()-1，我也被坑了，之前习惯u>=size()了）返回1；若为0，说明该位置永远也到不了终点，返回-1；

只要扩展有一个能到终点，就往上返回1，否则返回0；

class Solution {
public:
    int dfs(int u,vector<int>& nums,vector<int> &st){
        if(st[u]!=-1) return st[u];
        if(u>=nums.size()-1) return st[u]=1;
        if(!nums[u]) return st[u]=0;

        for(int ne=1;ne<=nums[u]&&u+ne<nums.size();ne++){
            int x=u+ne;
            if(dfs(x,nums,st)==1){
                return st[u]=1;
            }
        }
        return st[u]=0;
    }

    bool canJump(vector<int>& nums) {
        vector<int> st(nums.size(),-1);
        int ans=dfs(0,nums,st); 
        return ans==1; 
    }
};

随想录思路：

计算覆盖范围，只要覆盖范围可以覆盖到终点，就能到达；

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

45.跳跃游戏II

dfs超时，记忆化没写好，麻了；

保证能到达终点，从后往前推，每次找到能到达当前位置的最前面的位置；

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

正向着来，计算覆盖范围，不断更新下一个覆盖范围，当走到当前覆盖范围终点时，步数++，启动下一个覆盖范围；

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