从零开始的刷LeetCode生活 第30期 301-310

class Solution {
public:
    set<string> res;
    vector<string> removeInvalidParentheses(string s) {
        int left = 0, right = 0;
        for(auto c : s)
            if(c == '(')
                left ++;
            else if(c == ')')
            {
                if(left) left --;
                else right ++;
            }
        dfs(s, 0, left, right);
        return vector<string>(res.begin(), res.end());
    }

    bool check(string &s) //检查是不是合法括号
    {
        int cnt = 0;
        for(auto c : s)
            if(c == '(')
                cnt ++;
            else if(c ==')')
            {
                cnt --;
                if(cnt < 0) return false;
            }
        return cnt == 0;
    }
    void dfs(string &s, int u, int left, int right)
    {
        if(u == s.size())
        {
            if(check(s)) res.insert(s);
            return;
        }
        
        if(left > 0 && s[u] == '(')
        {
            string tmp = s;
            s.erase(s.begin() + u);
            dfs(s, u, left - 1, right);
            s = tmp;
        }
        if(right > 0 && s[u] == ')')
        {
            string tmp = s;
            s.erase(s.begin() + u);
            dfs(s, u, left, right - 1);
            s = tmp;
        }
        dfs(s, u + 1, left, right);
    }
};

class NumArray {
public:
    vector<int>f;
    NumArray(vector<int>& nums) {
        int n = nums.size();
        f = vector<int>(n + 1, 0);
        for(int i = 1; i <= n; i ++)
            f[i] = f[i - 1] + nums[i - 1];
    }
    
    int sumRange(int i, int j) {
        return f[j + 1] - f[i];
    }
};

/**
 * Your NumArray object will be instantiated and called as such:
 * NumArray* obj = new NumArray(nums);
 * int param_1 = obj->sumRange(i,j);
 */

class NumMatrix {
public:
   vector<vector<int>>f;
   NumMatrix(vector<vector<int>>& matrix) {
       if(matrix.empty())return;
       int n = matrix.size(), m = matrix[0].size();
       f = vector<vector<int>>(n + 1, vector<int>(m + 1, 0));
       for(int i = 1; i <= n; i++)
           for(int j = 1; j <= m; j ++)
               f[i][j] = f[i - 1][j] + matrix[i - 1][j - 1];
       for(int i = 1; i <= n; i ++)
           for(int j = 1; j <= m; j ++)
               f[i][j] += f[i][j - 1];
   }
   
   int sumRegion(int row1, int col1, int row2, int col2) {
       return f[row2 + 1][col2 + 1] + f[row1][col1] - f[row1][col2 + 1] -f[row2 + 1][col1];
   }
};

/**
* Your NumMatrix object will be instantiated and called as such:
* NumMatrix* obj = new NumMatrix(matrix);
* int param_1 = obj->sumRegion(row1,col1,row2,col2);
*/

class Solution {
public:
   bool isAdditiveNumber(string num) {
       int n = num.size();
       for(int i = 0; i < n / 2; i ++)
           for(int j = i + 1; j < n - 1; j ++)
               if(dfs(num, 0, i, i + 1, j)) return true;
       return false;
   }

   bool dfs(string & num, int l1, int r1, int l2, int r2)
   {
       if((r1 > l1 && num[l1] == '0') || (r2 > l2 && num[l2] == '0')) return false;
       if(r2 == num.size() - 1) return true;
       string s1 = num.substr(l1, r1 - l1 + 1);
       string s2 = num.substr(l2, r2 - l2 + 1);
       string s3 = add(s1, s2);
       int n = s3.size();
       //compare 比较s3的0-n 和 num 的 r2+1 - n 是否相同
       if(r2 + n >= num.size() || s3.compare(0, n, num, r2 + 1, n) != 0) return false;
       return dfs(num, l2, r2, r2 + 1, r2 + n);
   }

   string add(const string&s1, string &s2)
   {
       string res;
       int n1 = s1.size(), n2 = s2.size();
       int carry = 0;
       int i = n1 - 1, j = n2 - 1;
       while(~i || ~j || carry > 0)
       {
           int t1 = (i >= 0) ? s1[i--] - '0' : 0;
           int t2 = (j >= 0) ? s2[j --] - '0' : 0;
           res += ((t1 + t2 + carry) % 10) + '0';
           carry = (t1 + t2 + carry) / 10;
       }
       reverse(res.begin(), res.end());
       return res;
   }
};

class NumArray {
public:
    vector<int>a, f, sum;
    int n;
    NumArray(vector<int>& nums) {
        n = nums.size();
        a = nums;
        f = vector<int>(n + 1, 0);
        sum = vector<int>(n + 1, 0);
        for(int i = 1; i <= n; i ++)
            sum[i] = sum[i - 1] + nums[i - 1];
    }
    
    void update(int i, int val) {
        int x = i;
        for(x ++; x <= n; x += x & -x)
            f[x] += val - a[i];
        a[i] = val;
    }

    int prefixSum(int x)
    {
        int res = 0;
        for(; x; x -= x & -x)
            res += f[x];
        return res;
    }
    
    int sumRange(int i, int j) {
        return prefixSum(j + 1) - prefixSum(i) + sum[j + 1] - sum[i];
    }
};

/**
 * Your NumArray object will be instantiated and called as such:
 * NumArray* obj = new NumArray(nums);
 * obj->update(i,val);
 * int param_2 = obj->sumRange(i,j);
 */

class Solution {
public:
   int maxProfit(vector<int>& prices) {
       int n = prices.size();
       vector<vector<int>> f(n + 1, vector<int>(3));
       //f[i][0] 前i天持有收益 f[i][1]前i天卖完收益 f[i][2]前i天没有交易 i-1交易
       f[0][0] = INT_MIN, f[0][1] = f[0][2] = 0;
       for(int i = 1; i <= n; i ++)
       {
           f[i][0] = max(f[i - 1][0], f[i - 1][2] - prices[i - 1]);
           f[i][1] = f[i - 1][0] + prices[i - 1];
           f[i][2] = max(f[i - 1][1], f[i - 1][2]);
       }
       return max(f[n][1], f[n][2]);
   }
};

class Solution {
public:
    vector<int> findMinHeightTrees(int n, vector<vector<int>>& edges) {
        if(n == 1) return vector<int>{0};
        vector<vector<int>>tree(n);
        vector<int> deg(n, 0);
        for(auto &e : edges)
        {
            tree[e[0]].push_back(e[1]);
            tree[e[1]].push_back(e[0]);
            deg[e[0]] ++;
            deg[e[1]] ++;
        }
        vector<int> res;
        for(int i = 0; i < n; i ++)
            if(deg[i] == 1)
                res.push_back(i);
        while(n > 2)
        {
            vector<int> next_res;
            for(auto &u : res)
            {
                n --;
                for(auto &v : tree[u])
                {
                    deg[v]--;
                    if(deg[v] == 1)
                        next_res.push_back(v);
                }
            }
            res = next_res;
        }
        return res;
    }
};