Leetcode 455 376 53 122 55 45 988 1022

455. Assign Cookies

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());

        int index = s.size()-1;
        int res = 0;
        for(int i=g.size()-1; i>=0; i--){
            if(index >= 0 && g[i] <= s[index]){
                index--;
                res++;
            }
        }

        return res;
    }
};

376. Wiggle Subsequence

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        if(nums.size() <= 0) return nums.size();
        int curdif = 0;
        int predif = 0;
        int res = 1;
        for(int i=0; i< nums.size()-1; i++){
            curdif = nums[i+1] - nums[i];
            if((curdif < 0 && predif >= 0) || (curdif > 0 && predif <=0 )){
                res ++;
                predif = curdif;
            }
        }

        return res;
    }
};

53. Maximum Subarray

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int res = INT_MIN;
        int sum = 0;
        for(int i=0; i<nums.size(); i++){
            sum += nums[i]; 
            res = max(res, sum);
            if(sum <= 0){
                sum = 0;
            }
        }
        return res;
    }
};

第一遍写的时候就进入了常见的误区：

想到了负数对连续和的影响，但是有影响的是连续和为负数而不是遇到负数就返回

122. Best Time to Buy and Sell Stock II

因为每天只能买入一支股票，所以它就是每天正向利润的总和

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

        return res;
    }
};

（也可以用动态规划，之后在写）

55. Jump Game

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

        return true;
    }
};

45. Jump Game II

记录错误的代码：

class Solution {
public:
    int jump(vector<int>& nums) {
        int farthestJump = 0;
        int count = 0;
        int index = 0;
        for(int i=0; i< nums.size() -1; i++){
            if((farthestJump < i+nums[i]) && (farthestJump < nums.size()-1)){
                count ++;
                farthestJump = i+nums[i];

            }
        }

        return count;
    }
};

正确代码：

class Solution {
public:
    int jump(vector<int>& nums) {
        int farthestJump = 0;
        int count = 0;
        int curJump = 0;
        for(int i=0; i< nums.size() -1; i++){
            farthestJump = max(farthestJump, nums[i]+i);
            if((i == curJump) && (curJump < nums.size()-1)){
                count ++;
                curJump = farthestJump;
            }
        }

        return count;
    }
};

两个代码的区别是，一个是遇到更大的就计数，一个是这一步走完再计数走到这区间中的另一个最大值

复习二叉树

988. Smallest String Starting From Leaf

class Solution {
private:
    string path;
    string res = "";

    void traversal(TreeNode* root){
        if(root == NULL) return;
        if(root->left == NULL && root->right == NULL){
            path += root->val + 'a';
            reverse(path.begin(), path.end());

        
            if(res.empty() || res.compare(path) > 0){
                res = path;
            }

            reverse(path.begin(), path.end());
            path.pop_back();
            return;
        }

        path += root->val + 'a';
        traversal(root->left);
        traversal(root->right);

        path.pop_back();
    }
public:
    string smallestFromLeaf(TreeNode* root) {
        traversal(root);
        return res;
    }
};

string.compare的用法

s.compare （s2);

若参与比较的两个串值相同，则函数返回 0；若字符串 S 按字典顺序要先于 S2，则返回负值；反之，则返回正值。

1.比较的是字典顺序

2.逐字符比较，从前往后，比较出结果后就结束

1022. Sum of Root To Leaf Binary Numbers

class Solution {
private:
    int sum = 0;
    void traversal(TreeNode* root, int num){
        num = num*2+root->val;
        if(root->left == NULL && root->right == NULL){
            sum += num;
        }
       
        if(root->left) traversal(root->left, num);
        if(root->right) traversal(root->right, num);
        num = (num-root->val)/2;
    }
public:
    int sumRootToLeaf(TreeNode* root) {
        traversal(root, 0);
        return sum;
    }
};

要注意位置！

先加还是判断，还是先判断再加