<p>Given a string <font face="monospace">s</font> of <code>&#39;(&#39;</code> , <code>&#39;)&#39;</code> and lowercase English characters.</p>

<p>Your task is to remove the minimum number of parentheses ( <code>&#39;(&#39;</code> or <code>&#39;)&#39;</code>, in any positions ) so that the resulting <em>parentheses string</em> is valid and return <strong>any</strong> valid string.</p>

<p>Formally, a <em>parentheses string</em> is valid if and only if:</p>

<ul>
	<li>It is the empty string, contains only lowercase characters, or</li>
	<li>It can be written as <code>AB</code> (<code>A</code> concatenated with <code>B</code>), where <code>A</code> and <code>B</code> are valid strings, or</li>
	<li>It can be written as <code>(A)</code>, where <code>A</code> is a valid string.</li>
</ul>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> s = &quot;lee(t(c)o)de)&quot;
<strong>Output:</strong> &quot;lee(t(c)o)de&quot;
<strong>Explanation:</strong> &quot;lee(t(co)de)&quot; , &quot;lee(t(c)ode)&quot; would also be accepted.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> s = &quot;a)b(c)d&quot;
<strong>Output:</strong> &quot;ab(c)d&quot;
</pre>

<p><strong class="example">Example 3:</strong></p>

<pre>
<strong>Input:</strong> s = &quot;))((&quot;
<strong>Output:</strong> &quot;&quot;
<strong>Explanation:</strong> An empty string is also valid.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= s.length &lt;= 10<sup>5</sup></code></li>
	<li><code>s[i]</code> is either&nbsp;<code>&#39;(&#39;</code> , <code>&#39;)&#39;</code>, or lowercase English letter.</li>
</ul>

class Solution {
    public:

    string minRemoveToMakeValid(string s) {

        std::vector<bool> to_remove(s.size(), false);
        std::vector<int> index(s.size(), -1);


        std:stack<int> paren;

        for (size_t i=0;i< s.size();i++ ) {
            const char c = s[i];
            if (c == '(') {
                paren.push(i);
            }
            if (c == ')') {
                if (paren.empty()) {
                    to_remove[i] = true;
                } else {
                    paren.pop();
                }
            }            
        }

        while(!paren.empty()) {
            to_remove[paren.top()] = true;
            paren.pop();
        }

        std::string result;
        for (size_t i=0;i<s.size();i++) {
            if (!to_remove[i]) {
                result.push_back(s[i]);
            }
        }
        return result;
    }










/*


    string minRemoveToMakeValid2(string s) {

        std::vector<int> stack;
        std::vector<int> invalid;

        for (size_t i = 0; i < s.size(); i++) {
            const char ch = s[i];
            switch (ch) {
            case '(':
                stack.push_back(i);
                break;
            case ')':
                if (stack.size() > 0) {
                    stack.pop_back();
                }
                else {
                    invalid.push_back(i);
                }
                break;
            default:
                break;
            }
        }


        std::string output;
        for (size_t i = 0; i < s.size(); i++) {
            const char ch = s[i];
            if (ch == '(' || ch == ')') {
                if (std::find(stack.begin(), stack.end(), i) != stack.end()) {
                    continue;
                }
                if (std::find(invalid.begin(), invalid.end(), i) != invalid.end()) {
                    continue;
                }

            }
            output += ch;
        }
        return output;
    }

    */
};
16700