Leetcode Weekly Contest 131

菜狗Leetcode比赛都打得爆炸，赛后写一写题解吧
1021. Remove Outermost Parentheses
分析：每找到一个合法的括号序列，把首位和末尾删掉

class Solution {
public:
    string removeOuterParentheses(string S) {
        int len=S.length();
        string res="";
        int cnt=0,pos=0;
        for(int i=0;i<len;i++){
            if(S[i]=='(') cnt++;
            else cnt--;
            if(cnt==0){
                if(i-1==pos){
                    res+="";
                }else{
                    res+=S.substr(pos+1,i-pos-1);
                }
                pos=i+1;
            }
        }
        return res;
    }
};

1022. Sum of Root To Leaf Binary Numbers
分析：dfs一下，水题

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
const int mod=1e9+7;
class Solution {
public:
    int solve(string s){
        int len=s.length();
        int ans=0;
        for(int i=0;i<len;i++){
            ans*=2;
            ans+=s[i]-'0';
            ans%=mod;
        }
        return ans;
    }
    void dfs(TreeNode* root,string res,int &sum){
        res+=to_string(root->val);
        if(root->left==NULL&&root->right==NULL){
            sum+=solve(res);
            sum%=mod;
            res.pop_back();
            return;
        }
        if(root->left) dfs(root->left,res,sum);
        if(root->right) dfs(root->right,res,sum);
        res.pop_back();
    }
    int sumRootToLeaf(TreeNode* root) {
        if(root==NULL) return 0;
        if(root->left==NULL&&root->right==NULL) return root->val;
        string res="";
        int sum=0;
        dfs(root,res,sum);
        return sum;
    }
};

1023. Camelcase Matching
分析：100的数据范围，暴力就可以过吧

class Solution {
public:
    bool judge(string s,string p){
        int lens=s.length(),lenp=p.length();
        int i=0,j=0;
        while(i<lens){
            if(s[i]==p[j]) {i++;j++;}
            else if(s[i]>='a'&&s[i]<='z') {i++;continue;}
            else return false;
        }
        return j==lenp;
    }
    vector<bool> camelMatch(vector<string>& queries, string pattern) {
        vector<bool>res;
        for(auto v:queries){
            res.push_back(judge(v,pattern));
        }
        return res;
    }
};

1024. Video Stitching
分析：首先我们按照开始时间进行排序，然后可以进行dp，dp[i]表示前i个最少使用多少个，注意，一定要从0开始的状态才能进行转移，然后不断更新dp[i]，最后大于T的合法i位置选出最小的即可。

struct node{
    int l,r;
};
bool cmp(node a,node b){
    return a.l<b.l;
}
class Solution {
public:
    int videoStitching(vector<vector<int>>& clips, int T) {
        vector<node>v;
        int n=clips.size();
        for(int i=0;i<n;i++){
            node tmp;
            tmp.l=clips[i][0],tmp.r=clips[i][1];
            v.push_back(tmp);
        }
        sort(v.begin(),v.end(),cmp);
        if(v[0].l!=0) return -1;
        int dp[n+10];
        memset(dp,0,sizeof(dp));
        for(int i=0;i<n;i++) dp[i]=INT_MAX;
        for(int i=0;i<n;i++){
            if(v[i].l==0) dp[i]=1;
        }
        for(int i=0;i<n;i++){
            for(int j=0;j<i;j++){
                if(dp[j]!=INT_MAX&&v[i].l<=v[j].r){
                    dp[i]=min(dp[i],dp[j]+1);
                }
            }
        }
        int ans=INT_MAX;
        for(int i=0;i<n;i++){
            if(v[i].r>=T) ans=min(ans,dp[i]);
        }
        if(ans==INT_MAX) return -1;
        return ans;
    }
};

转载于:https://www.cnblogs.com/gzgywh/p/10713387.html