P32: accepted (optimal version with editorial)

Author: andrewzolotukhin

P00032LongestValidParanthesis/index.js

@@ -1,12 +1,27 @@
 var longestValidParentheses = function (s) {
-  if (s.lenth <= 1) return 0;
+  if (s.length <= 1) return 0;
 
   const levels = s.split().map(() => 0);
-  const negs = [-1];
 
-  levels[0] = s[0] === "(" ? 1 : -1;
+  let i = 0;
+  while (s[i] === ")" && i < s.length) {
+    i++;
+  }
+
+  if (i >= s.length) return 0;
+
+  levels[i] = s[i] === "(" ? 1 : -1;
+
+  const negs = [];
+  negs.push(i - 1);
+
+  let hasOpen = false;
+
+  if (i == 0) i++;
 
-  for (let i = 1; i < s.length; i++) {
+  for (; i < s.length; i++) {
+    //     if(s[i] === ")" && !hasOpen) continue;
+    //     hasOpen = true;
     levels[i] = levels[i - 1] + (s[i] === "(" ? 1 : -1);
     if (levels[i] < 0 && levels[i - 1] >= 0) negs.push(i);
   }
@@ -15,23 +30,26 @@ var longestValidParentheses = function (s) {
 
   let result = 0;
   for (let i = 1; i < negs.length; i++) {
-    const l = -levels[negs[i]] + (negs[i] - negs[i - 1] - 1);
-    if (l < result) result = l;
+    //     console.log(negs[i], negs[i - 1], levels[negs[i] - 1]);
+    const l = negs[i] - negs[i - 1] - 1 - levels[negs[i] - 1];
+    if (l > result && Math.abs(negs[i] - negs[i - 1] - 1) > 1) result = l;
   }
 
-  console.log(negs);
-  console.log(levels);
+  console.log("negs:", negs);
+  console.log("levels:", levels);
   return result;
 };
 
 const tests = [
   { i: "()", o: 2 },
   { i: ")(", o: 0 },
+  { i: "())(", o: 2 },
   { i: ")()", o: 2 },
   { i: ")())", o: 2 },
   { i: ")()())", o: 4 },
   { i: ")()((((((((((())))))))))))", o: 24 },
   { i: "(()", o: 2 },
+  { i: "()(()", o: 2 },
 ];
 
 for (let { i, o } of tests) {

P00032LongestValidParanthesis/solution.cpp

@@ -0,0 +1,40 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+class Solution {
+public:
+  int longestValidParentheses(string s) {
+    stack<int> stack;
+    stack.push(-1);
+    int maxLen = 0;
+
+    for (int i = 0; i < s.size(); i++) {
+      auto last = stack.top();
+      if (last != -1 && s[i] == ')' && s[last] == '(') {
+        stack.pop();
+        maxLen = max(maxLen, i - stack.top());
+      } else {
+        stack.push(i);
+      }
+    }
+
+    return maxLen;
+  }
+};
+
+int main() {
+  Solution sol;
+  string s;
+
+  cin >> s;
+
+  if (s.size() == 0) {
+    cout << 0 << endl;
+    return 0;
+  }
+
+  cout << sol.longestValidParentheses(s) << endl;
+
+  return 0;
+}

P00032LongestValidParanthesis/solution_accepted_slow.cpp

@@ -0,0 +1,89 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+class Solution {
+public:
+  int find(string &s, int start, vector<int> &memo) {
+    if (start >= s.size() - 1)
+      return 0;
+
+    if (memo[start] != -1) {
+      return memo[start];
+    }
+
+    if (s[start] != '(') {
+      memo[start] = 0;
+      return 0;
+    }
+
+    if (s[start + 1] == ')') {
+      memo[start] = 2;
+      return 2;
+    }
+
+    auto nextChar = start + 1;
+    auto totalInner = 0;
+
+    while (true) {
+      auto inner = find(s, nextChar, memo);
+
+      if (inner == 0) {
+        break;
+      }
+      totalInner += inner;
+      nextChar += inner;
+    }
+
+    if (start + totalInner + 1 >= s.size()) {
+      memo[start] = 0;
+      return 0;
+    }
+
+    if (s[start + totalInner + 1] == ')') {
+      memo[start] = totalInner + 2;
+      return totalInner + 2;
+    }
+
+    return 0;
+  }
+
+  int longestValidParentheses(string s) {
+    int currentIndex = 0;
+    int max = 0;
+    int currentGroup = 0;
+    vector<int> memo(s.size(), -1);
+
+    while (currentIndex < s.size()) {
+      auto result = find(s, currentIndex, memo);
+      if (result == 0) {
+        currentGroup = 0;
+        currentIndex++;
+      } else {
+        currentGroup += result;
+        currentIndex += result;
+        if (currentGroup > max) {
+          max = currentGroup;
+        }
+      }
+    }
+
+    return max;
+  }
+};
+
+int main() {
+  Solution sol;
+  string s;
+
+  cin >> s;
+
+  if (s.size() == 0) {
+    cout << 0 << endl;
+    return 0;
+  }
+
+  cout << sol.longestValidParentheses(s) << endl;
+
+  return 0;
+}

P00032LongestValidParanthesis/tests/test1

@@ -0,0 +1 @@
+))))()

P00032LongestValidParanthesis/tests/test1.out

@@ -0,0 +1 @@
+2

P00032LongestValidParanthesis/tests/test2

@@ -0,0 +1 @@
+)()())

P00032LongestValidParanthesis/tests/test2.out

@@ -0,0 +1 @@
+4

P00032LongestValidParanthesis/tests/test3

@@ -0,0 +1,2 @@
+
+

P00032LongestValidParanthesis/tests/test3.out

@@ -0,0 +1 @@
+0

P00032LongestValidParanthesis/tests/test4

@@ -0,0 +1 @@
+((()))