Problem 171: Remove invalid parenthesis

Author: mandliya

.gitignore

@@ -35,3 +35,6 @@ build/
 #vim backup
 *.cpp~
 *~
+
+#VS code
+.vscode

README.md

@@ -6,7 +6,7 @@
 
 | Current Status|     Stats     |
 | :------------: | :----------: |
-| Total Problems | 170 |
+| Total Problems | 171 |
 
 </center>
 
@@ -242,4 +242,5 @@ Include contains single header implementation of data structures and some algori
 |Given a sorted array, remove duplicates in place and return the new length. It doesn't matter what is in array beyond the unique elements size. Expected O(1) space and O(n) time complexity.| [remove_duplicates.cpp](leet_code_problems/remove_duplicates.cpp) |
 | Count the number of islands in a grid. Given a grid representing 1 as land body, and 0 as water body, determine the number of islands (more details in problem comments)|[count_islands.cpp](leet_code_problems/count_islands.cpp)|
 | Find median from a data stream. Design a data structure that supports addNum to add a number to the stream, and findMedian to return the median of the current numbers seen so far. Also, if the count of numbers is even, return average of two middle elements, return median otherwise.|[median_stream.cpp](leet_code_problems/median_stream.cpp)
+| 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 ) | [remove_invalid_parenthesis.cpp](leet_code_problems/remove_invalid_parenthesis.cpp)|
 

leet_code_problems/remove_invalid_parenthesis.cpp

@@ -0,0 +1,107 @@
+/*
+ * 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 ).
+ * 
+ * Source: Leetcode, 301. Remove Invalid Parentheses
+ * 
+ * solution approach:
+ * 
+ * We can solve this problem in many ways, I am choosing DFS.
+ * For a string to be valid, we have two requirements:
+ * 1. The number of left and right parenthesis should be same.
+ * 2. They should be in right order, for each open there has to be a close, so for example '()' is valid
+ * but ')(' is not.
+ * 
+ * 1. We track the count of left and right parenthesis which are out of place.
+ * 2. We recursively backtrack and go two ways.
+ * If a character is left or right parenthesis,
+ *  a.  we keep it
+ *  b. or we drop it.
+ * 3. In both the cases we adjust open left and right parameters accordingly.
+ * Open is the count of parenthesis sets which are open but not close yet.
+ * When we reach end of string, we check if it is valid by left, right and open count and
+ * push the string to result set.
+ * 4. If a character is not a parenthesis operator, we simply add it to the result string.
+ * 5. At the end of backtracking, we simply replace the current result string with the one
+ * we started this iteration with.
+ * 
+ * We are using a set to keep the results unique.
+ * 
+ */
+
+
+#include <iostream>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+void dfs(const std::string& s, std::string temp, int index, int left, int right, int open,
+            std::unordered_set<std::string>& result)
+{
+    if (index == s.length()) {
+        if (left == 0 && right == 0 && open == 0) {
+            result.insert(temp);
+        }
+        return;
+    }
+    
+    if (left < 0 || right < 0 || open < 0) {
+        return;
+    }
+    
+    std::string current{temp};
+    char c = s[index];
+    if (c == '(') {
+        // Drop
+        dfs(s, temp, index + 1, left - 1, right, open, result);
+        // Keep
+        dfs(s, temp + c, index + 1, left, right, open + 1, result);
+    } else if (c == ')') {
+        // Drop
+        dfs(s, temp, index + 1, left, right - 1, open, result);
+        // Keep
+        dfs(s, temp + c, index + 1, left, right, open - 1, result);
+    } else {
+        dfs(s, temp + c, index + 1, left, right, open, result);
+    }
+    
+    temp = current;
+}
+
+std::vector<std::string> remove_invalid_parenthesis(const std::string& s) {
+    std::vector<std::string> result;
+    if (s.length() == 0) {
+        result.push_back("");
+        return result;
+    }
+    int left = 0;
+    int right = 0;
+    for (char c : s) {
+        if (c == '(') left++;
+        else if (c == ')') {
+            if (left > 0) left--;
+            else right++;
+        }
+    }
+    std::unordered_set<std::string> result_set;
+    std::string temp("");
+    dfs(s, temp, 0, left, right, 0, result_set);
+    return std::vector<std::string>(result_set.begin(), result_set.end());
+}
+
+template<typename T>
+void print_vec(const std::vector<T>& vec) {
+    for (auto v: vec) {
+        std::cout << v << " ";
+    }
+    std::cout << std::endl;
+}
+
+int main()
+{
+    std::string str("(a)())()");
+    std::cout << "Pattern: " << str << std::endl;
+    std::cout << "Possible valid parenthesis combinations: ";
+    print_vec(remove_invalid_parenthesis(str));
+}