leetcode:最长上升子序列 && leetcode：删除无效的括号

最长上升子序列：题目描述

解题思路

暴力法

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        if(nums.size() == 0) return 0;
        if(nums.size() == 1) return 1;
        int res = 1;
        for(int i = 0; i < nums.size(); i++){
            int len = 1;
            vector<vector<int>> temp;
            temp.push_back({nums[i]});
            
            for(int j = i + 1; j < nums.size(); j++){
                if(nums[j] <= nums[i]) continue;
                
                for(int k = 0; k < temp.size(); k++){
                    if(nums[j] > temp[k][temp[k].size() - 1]){
                        temp[k].push_back(nums[j]);  
                    }
                    if(nums[j] < temp[k][temp[k].size() - 1] && nums[j] > temp[k][temp[k].size() - 2])
                        temp[k][temp[k].size() - 1] = nums[j];
                }
            }
            
            for(int j = 0; j < temp.size(); j++)
                res = max(res,(int)temp[j].size());
        }//最外层的for循环
        return res;
    }
};

改进版暴力法：维护一个最长的子序列

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
    vector<int>longs;
    for(int c:nums){
        int j;
        for(j = 0 ; j < longs.size();j++){
            if(c <= longs[j])break;
        }
        if(j == longs.size())longs.push_back(c);
        else longs[j] = c;
    }
        return longs.size();
    }


};

删除无效的括号：题目描述

删除最小数量的无效括号，使得输入的字符串有效，返回所有可能的结果。

说明: 输入可能包含了除 ( 和 ) 以外的字符。

示例 1:

输入: “()())()”
输出: ["()()()", “(())()”]
示例 2:

输入: “(a)())()”
输出: ["(a)()()", “(a())()”]
示例 3:

输入: “)(”
输出: [""]

解题思路

计算左括号的个数和右括号的个数。
如果出现右括号比左括号多的情况，则选择删除一个右括号，然后进行回溯
如果左括号的个数比右括号的个数多，则从右往左，选择删除多余的左括号，回溯。

class Solution {
public:
    vector<string> removeInvalidParentheses(string s){
        return removeInvalidParentheses(s,0,{'(',')'});
    }
    vector<string> removeInvalidParentheses(string s,int start,const vector<char> pair) {
        if(s.size() == 0) return {""};

        int stack = 0;
        for(int i = start; i < s.size(); i++){
            if(s[i] == pair[0]) stack++;
            if(s[i] == pair[1]) stack--;
            if(stack >= 0) continue;

            //多出来一个的时候，就可以删除前面的一个右括号
            //这里代表的时右括号多了
            //set用于去重
            set<string> temp;
            for(int j = 0; j <= i; j++){
                vector<string> resj;
                if(s[j] == pair[1] && (j == 0 || s[j - 1] != pair[1]))
                    resj = removeInvalidParentheses(s.substr(0,j) + s.substr(j + 1),i,pair);
                for(int k = 0; k < resj.size(); k++)
                    temp.insert(resj[k]);
            }
            vector<string> res;
            for(auto ss:temp)
                res.push_back(ss);
            return res;
        }

        //左括号和右括号的个数相等
        if(stack == 0) return {s};

        //左括号的个数比右括号的个数多
        reverse(s.begin(),s.end());
        vector<string> res = removeInvalidParentheses(s,0,{')','('});
        for(int i = 0; i < res.size(); i++)
            reverse(res[i].begin(),res[i].end());

        return res;
    }
};