代码随想录训练营day28|122.买卖股票的最佳时机 II，55. 跳跃游戏，45.跳跃游戏 II，1005.K次取反后最大化的数组和

买股票

题目

想法：感觉好像和摆动序列差不多？如果知道一直股票后一天会涨，就在它到顶峰的时候卖掉。如果手里没有股票，且明天的股价会下跌，那就在谷底时买入;如果持股时知道明天股价回跌，那就当天卖掉，谷底买入。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int money=0;
        bool gupiao=false;
        for(int i=0;i<prices.size();i++){
            if(gupiao==false){
                while(i<prices.size()-1&&prices[i+1]<=prices[i])
                    i++;//找到股票的最低点
                cout<<prices[i]<<"买入"<<endl;
                money-=prices[i];
                gupiao=true;
            }
            else if(gupiao){
                while(i<prices.size()-1&&prices[i+1]>=prices[i]){
                    i++;//找到股票的最高点
                }//如果i在这里没有移动，说明明天价格更低，直接出手买明天股票
                money+=prices[i];
                cout<<"卖出"<<prices[i]<<endl;
                gupiao=false;
            }
        }
        if(gupiao==true)//如果最后一天是最低点，没卖出去的话
            money+=prices[prices.size()-1];
        return money;
    }
};

另一种解法

把它分为n-1个相邻区间，每两天之间的利润是nums[i]-nums[i-1]
如果利润为正的话就收集它。这个思路和那个求连续数组最大和就比较像了。

跳跃游戏1

题目

想法：cur指针指向当前下标，在它的范围内，找到i+nums[i]最远的下标，也就是能碰到的最远范围，然后再让cur指向它

 bool dfs(vector<int> &nums,int cur){//如果不用引用的话会每次使用时复制，这样某些特殊案列会过不了。
        int max=cur+nums[cur];//当前下标能达到的最大范围
        int next=cur;
        for(int i=cur;i<nums.size()&&i<=(cur+nums[cur]);i++){
            int index=i+nums[i];
            if(index>=max){
                next=i;
                max=index;
            }
            if(max>=nums.size()-1)
                return true;
        }
        if(nums[cur]==0&&cur<nums.size()-1)
            return false;
        return dfs(nums,next);
    }
    bool canJump(vector<int>& nums) {
        int cur=0;
        return dfs(nums,cur);
        
    }

也可以直接写一个for循环，用max作为边界，然后动态的去更新max，这个思路很巧妙。

跳跃游戏2

题目

想法, 这题求最小跳跃次数，所以用更新max的方法就不行了，就老老实实的递归呗，找到每个区间对应的最大max，然后count++。然后就是针对特殊情况的一些处理。

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

K次取反后最大化的数组和

想法，先排序，把从小到达取反，在nums[i]》0时再次排序，从小到大取K-i个

第一次贪心：优先取反负数

 sort(nums.begin(),nums.end());
 int count=0;
 if(nums[0]<0){
    for(int i=0;i<nums.size()&&i<k&&nums[i]<0;i++){
         nums[i]=-nums[i];//把负数全部反过来
         count++;
     }
 }
 sort(nums.begin(),nums.end());
 //现在全是正数了或者count已经用完了

第二次贪心：取反最小的

if((k-count)%2==1)
	nums[0]=-nums[0];

如果还有奇数个剩余次数，对最小的正数进行操作