Question

我在leetcode上解决了这个问题，问题陈述如下。

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

注意：输入字符串可能包含括号（和）以外的字母。

Examples:
"()())()" -> ["()()()", "(())()"]
"(a)())()" -> ["(a)()()", "(a())()"]
")(" -> [""]

过了一会儿，我才能解决问题。但我无法找到解决方案的时间复杂性。我的代码如下。请帮我找时间复杂度。

    class Solution {
public:

    void balance(string s, int curr_index, int changes, int max_changes, unordered_set<string> &memo, vector<string> &result){

        if(memo.find(s) != memo.end()){
            return;
        }

        if(changes == max_changes){
            int opening = 0;
            for(int i = 0; i < s.length(); i++){
                if(s[i] == '('){
                    opening++;
                }
                else if(s[i] == ')'){
                    if(opening == 0){
                        return;
                    }
                    else{
                        opening--;
                    }
                }
            }
            if(opening == 0){
                result.push_back(s);
            }
        }
        else if(changes > max_changes || curr_index >= s.length()){
            return;
        }
        else{
            if(s[curr_index] == '(' || s[curr_index] == ')'){
                string temp = s;
                temp.erase(temp.begin() + curr_index);
                balance(temp, curr_index, changes + 1, max_changes, memo, result);
            }

            balance(s, curr_index + 1, changes, max_changes, memo, result);
        }

        memo.insert(s);

    }


    vector<string> removeInvalidParentheses(string s) {

        int opening = 0;
        int min_changes = 0;

        vector<string> result;

        for(int i = 0; i < s.length(); i++){
            if(s[i] == ')' && opening == 0){
                min_changes++;
            }
            else if(s[i] == ')' && opening != 0){
                opening--;
            }
            else if(s[i] == '('){
                opening++;
            }
        }

        min_changes += opening;

        if(min_changes == s.length()){
            result.push_back("");
            return result;
        }
        else{

            unordered_set<string> memo;

            balance(s, 0, 0, min_changes, memo, result);

            return result;
        }

    }
    };

Answer 1

这是指数级的。你无能为力，因为输出大小可能是指数级的。

考虑以下示例：(a(a(a(a.....))))))，其中对(a的数量是右括号数的两倍。很明显，我们需要删除正好一半的左括号，并且很明显删除任何子集都会产生一个唯一的字符串。

让字符串的长度为5n。然后我们有2n'（'和'a'和n'）'。有2n选择n方法来删除左括号的子集并获取有效字符串，该字符串是字符串长度的指数。

删除无效的括号 - Leetcode时间复杂度

1 个答案: