LeetCode----301. Remove Invalid Parentheses----Hard

2018.3.25  Spring is coming 

Remove the minimum number of invalid parentheses in order to make the input string valid. Return all possible results.

Note: The input string may contain letters other than the parentheses ( and ).

Examples:

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

先说结果吧,这道题目我使用的是BFS，效率比较低。

使用的方法有点不够正规，这里记录一下，以后可能会更新更好更通用的方法。

思路分析：

如果把'(' 看成 +1 而把 ')'看成-1 ， 这样的话 ， 符合条件的括号序列首先要满足 整一个序列之和为0

例如()() ----> +1 -1 +1 -1 

序列之和为0仅仅是一个必要条件 ，因为  )()( ------> -1 +1 -1 +1之和也为0，但是不是正确的括号序列

所以正确的括号序列还应加上一个条件：从第一个开始加，直到加到最后一个 ，其 结果都不能小于0,

()())( ------>+1 -1 +1 -1 -1 +1 从第一个开始加到最后一个的和： 

+1   ---> 0----->+1 -----> 0 ------> -1 ----->小于0了 所以一定不符合要求 

有了这个基本的思路 我就可以进行BFS搜索了 

1.将括号和字母的序列 存成 一个vector 左括号存成 1 右括号存成-1，字母就存它本身的ASCII码

2.对初始序列进行判断 ，如果本身就已经是合理序列 就直接输出即可 ， 如果本身是错误序列，说明需要Remove掉一些括号

3.对错误的序列而言，将其状态可以转化成若干个状态 ， 例如：

()())()的情况，---->+1 -1 +1 -1 -1 +1 -1 它可以演变成以下几个状态

1）删除第一个括号----->-1 +1 -1 -1 +1 -1

2）删除第二个括号----->+1 +1 -1 -1 +1 -1

3）删除第三个括号-----> +1 -1 -1 -1 +1 -1

等等，当然要避免序列重复的情况 ，我是简单地将其放到一个set中来判断

4.对每一个演变出来的新序列判断其是否满足要求，一旦发现满足要求，就记录下当前序列的长度，因为我们需要找到所有满足要求的序列，这些序列有一个特点，就是长度肯定是一样的，一旦发现新序列的长度比这个记录的长度短的，那说明找完了，下面贴上我的渣渣代码，日后再来改-。-

class Solution {
public:
    vector removeInvalidParentheses(string s) {
        int size = s.size();
        queue> Q ;
        vector num ;
        vector> ans ;
        set> ss ;
        int lastSize = INT_MIN;
        bool isSuccess = true ;
        
        vector solution ;
        
        for(int i = 0 ; i < size ;i++)
        {
            if(s[i] == '(')
                num.push_back(1);
            
            else if(s[i] == ')')
                num.push_back(-1);
            
            else 
                num.push_back(s[i]);
        }
        int count = 0 ;
    
        for(int i = 0 ; i < num.size() ; i++)
        {
            if(num[i] == 1 || num[i] == -1)
            {
                count += num[i] ;
                if(count < 0)
                {
                    isSuccess = false ;
                }
            }
        }
        if(count == 0 && isSuccess == true)
        {
            ans.push_back(num);
        }
        else {
        Q.push(num);
        bool isFound = false ;
        while(Q.empty() == false)
        {
            
            vector temp = Q.front();            
            Q.pop();
            
            if(isFound == true && temp.size() == lastSize)
            {
                break;
            }
            
            for(int i = 0 ; i < temp.size() ; i++)
            {
                isSuccess = true ;
                vector fuzhi(temp);
                vector::iterator deletei = fuzhi.begin();
                count = 0 ;
                for(int j = 0 ; j < temp.size() ; j++)
                {
                    //如果不是括号，是字母的话，就可以跳过
                    if(temp[j] == 1 || temp[j] == -1)
                    {
                        if(j != i)
                        {
                            count += temp[j] ;
                            if(count < 0)
                                isSuccess = false ;
                        }
                    }
                    else 
                        continue;
                }
                if(fuzhi[i] == 1 || fuzhi[i] == -1)
                    fuzhi.erase(deletei+i);
                if(count == 0 && isSuccess == true)
                {
                    isFound = true ;
                    lastSize = fuzhi.size();
                    if(ss.insert(fuzhi).second == true)
                    {
                        Q.push(fuzhi);
                        ans.push_back(fuzhi);
                    }
                }
                else if(ss.insert(fuzhi).second == true)
                    Q.push(fuzhi);
                
                
            }
            
            
        }
        }
        if(ans.size() != 0)
        {
            for(int i = 0 ; i < ans.size() ; i++)
            {
                string temps ;
                for(int j = 0 ; j < ans[i].size() ; j++)
                {
                    if(ans[i][j] == 1)
                    {
                        temps.append(1,'(');
                    }
                    else if(ans[i][j] == -1)
                    {
                        temps.append(1,')');
                    }
                    else 
                    {
                        temps.append(1,ans[i][j]);
                    }
                }
                solution.push_back(temps);
            }
            return solution ;
        }
        solution.push_back("");
        return solution ;
    }
};

未完待续...