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

一、买卖股票最佳时机

        一开始想着用暴力，一个for循环遍历数组，然后再用一个for循环找到后面比他大的值，存放在最大值里，这样不仅漏情况，又超时

        题解的思路很巧妙，把一段时间的最大利润拆成每天相加减的最大利润

        

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

二、跳跃游戏

        第一遍做的时候没有读清题意，以为跳到哪，就必须按照对应的下标的步数跳，所以会漏掉很多用例。然后添加了步数区间中搜索最大可跳步数的操作后，通过用例仍然有少部分不通过的。

这是原先的代码：

这样会导致[2,0,1]因为最大值没有更替，一直在2原地跳

class Solution {
public:
    int findmax(vector<int>&nums,int start,int end){
        int maxindex=start;
        int max=nums[start];
        while(start<=end){
           
            if(max<=nums[start]){
                max=nums[start];
                maxindex=start;
            }
            start++;
        }
        return maxindex;
    }
    bool canJump(vector<int>& nums) {
        int index=0;
        int count=0;
        if(nums.size()==1)return true;
        while(1){
            
            
            if(index+nums[index]>=nums.size()-1)return true;
            index=findmax(nums,index,nums[index]+index); 
            count++;
           
            if(count>nums.size())break;
             
        }
        return false;


    }
};

更改后用覆盖面积的做法：

cover的意思是覆盖范围的末边界

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

        return false;
    }
};

 

 三、跳跃游戏Ⅱ

        一开始依然是用找最大值的方法做的，这样只是能够找到每一步能跳到接下来跳最远的 地方，并不能找到最后的最优解

        原来的代码：

        

class Solution {
public:
    int maxindex(vector<int>&nums,int start,int end){
        int maxindex=0;
        int max=0;
        for(;start<=end;start++){
            if(nums[start]>=max){
                max=nums[start];
                maxindex=start;
            }
        }
        return maxindex;
    }
    int jump(vector<int>& nums) {
        int count=0;
        int i=0;
        while(1){
          
            count++;
            if(nums.size()==1)return 0;
          
            if(i+nums[i]>=nums.size()-1)break;
            i=maxindex(nums,i+1,i+nums[i]);
           
        }
        return count;
    }
};

 覆盖范围的做法：

        

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

四、取反数组和

         直接排序，把最小的元素取反就行了

class Solution {
public:
    int largestSumAfterKNegations(vector<int>& nums, int k) {
        while(k--){
            sort(nums.begin(),nums.end());
            nums[0]=-nums[0];
        }
        int sum=0;
        for(int i=0;i<nums.size();i++){
                sum+=nums[i];
        }
       return sum;

    }
};