力扣刷题笔记

二分查找

35. 搜索插入位置

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int low=0, high=nums.size()-1,mid;
        while(low<=high){
            mid=(low+high)/2;
            if(nums[mid]==target){
                return mid;
            }
            else if(nums[mid]>target){
                high=mid-1;
            }
            else if(nums[mid]<target){
                low=mid+1;
            }
        }
        return low; //
    }
};

162 寻找峰值

public:
    int findPeakElement(vector<int>& nums) {
        int low=0,high=nums.size()-1,mid;
        while(low<high){
            mid=(low+high)/2;
            if(nums[mid+1]>nums[mid]){ //只要右边大于左边，那么在右边必然能找到峰值
                low=mid+1; //向右寻找
            }
            else    high=mid; //如果左边大于右边，就缩小范围
        }
        return low;
    }
};

长度最小的子数组

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int low=0, high=0, sum=0,len=nums.size()+1;
        while(high<=nums.size()){
            if(sum<target){
                if(high<nums.size()) sum+=nums[high];
                high++;    
            }
            if(sum>=target){
                if(high-low<len) len=high-low;
                sum-=nums[low];
                low++;
            }
        }
        if(len==nums.size()+1) 
            len=0;
        return len;
    }
};

定长子串中元音字母的最大数

class Solution {
public:
    bool yuan(char x){
        if(x=='a'||x=='e'||x=='i'||x=='o'||x=='u'){
            return true;
        }
        return false;
    }
    int maxVowels(string s, int k) {
        int sum=0;
        int maxsum=0;
        int i,j;
        for(i=0;i<k;i++){
            if(yuan(s[i])){
                sum++;
                maxsum++;
            }
        }
        for(j=k;j<s.size();j++){
            if(sum==k) return k;
            else{
                if(yuan(s[j])) sum++;
                if(yuan(s[j-k])) sum--;
                if(sum>maxsum) maxsum=sum;
            } 
        }
        return maxsum;
    }
};

687.最长同值路径

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int longst(TreeNode* root, int &maxlen){
        if(root==nullptr) return 0;
        int left=longst(root->left, maxlen);
        int right=longst(root->right, maxlen);
        if(root->left&&root->left->val==root->val)  left++;
        else left=0;
        if(root->right&&root->right->val==root->val) right++;
        else right=0;
        maxlen=max(maxlen,left+right);
        return max(left,right);
    }
    int longestUnivaluePath(TreeNode* root) {
        int maxlen=0;
        longst(root, maxlen);
        return maxlen;
    }
};

编写递归时，每一层只要考虑需要什么条件，让下一层去返回这个条件就好了

169.多数元素

简单分治，思路与递归一样

class Solution {
public:
    int find(vector<int>& nums, int low, int high){
        if(low==high) return nums[low];
        int left =find(nums, low, (low+high)/2);
        int rignt=find(nums, (low+high)/2+1, high);
        if(left==rignt) return left;
        else{
            int leftval=0,rigntval=0;
            for(int i=low;i<=high;i++){
                if(nums[i]==left)   leftval++;
                else    rigntval++;   
            }
            if(leftval>rigntval)    return left;
            else    return rignt;
        }
    }
    int majorityElement(vector<int>& nums) {
        return find(nums, 0, nums.size()-1);
    }
};

53.最大子数组和

class Solution {
public:
    typedef struct{
        int Lsum;
        int Rsum;
        int Msum;
        int Isum;
    }Note;
    Note get(Note L,Note R){
        int lsum=max(L.Lsum,L.Isum+R.Lsum);
        int rsum=max(R.Rsum,R.Isum+L.Rsum);
        int msum=max(max(L.Msum,R.Msum),L.Rsum+R.Lsum);
        int isum=L.Isum+R.Isum;
        return (Note){lsum,rsum,msum,isum};
    }
    Note func(vector<int>& nums, int low, int high){
        if(low==high) return (Note){nums[low],nums[low],nums[low],nums[low]};
        Note NoteL = func(nums,low, (low+high)/2);
        Note NoteR = func(nums,(low+high)/2+1,high);
        return get(NoteL,NoteR);
    }
    int maxSubArray(vector<int>& nums) {
        return func(nums,0,nums.size()-1).Msum;
    }
};

用分治的办法，每一层只考虑要什么参数能得出最终的结果，参数由底下一层提供。

22.括号生成

class Solution {
public:
    void dfs(vector<string>& fin, int left, int right, string ans, int n){
        while(right>left||left>n){
            return;
        }
        if(left==n&&right==n){
            fin.push_back(ans);
            return;
        }
        dfs(fin, left+1, right,ans+"(", n);
        dfs(fin, left, right+1,ans+")", n);
    }
    vector<string> generateParenthesis(int n){
        vector<string> fin;
        if(n==0) return fin;
        string ans;
        dfs(fin,0,0,ans, n);
        return fin;
    }
};

写递归时，先写出口，再写递归