just do it

20220509，11min,相隔1个月

|
```javascript /**

• @param {string} s
• @return {number} */ // 22:06 -> 22:17 var longestValidParentheses = function(s) { const len = s.length; let arr = new Array(len).fill(0); let stack = [] for (let i = 0; i < len; i++) {

   // if (s[i] === ')' ) { // bug:结果会比预期结果多
   // if (s[i] === ')' && stack.length > 0) { // bug：条件多，会走到stack.push中去
   if (s[i] === ')') {
       if (stack.length > 0) {
           arr[i] = 1;
           arr[stack.pop()] = 1;
       }
   } else {
       stack.push(i);
   }

  } let ans = 0; let sum = 0; for (let j = 0; j < len; j++) {

   if (arr[j] === 1) {
       sum+=1
       ans = Math.max(ans, sum)
   }
   if (arr[j] === 0) {
       sum = 0;
   }
  

  } return ans; }; ``` | | —- |

20220406，6min

| 20220406```javascript /**

• @param {string} s

• @return {number} */ // 09:33 -> 09:39 // 栈 var longestValidParentheses = function(s) { let stack = new Array(s.length).fill(0); let left = []; // 记录下标 for (let i = 0; i < s.length; i++) { if (s[i] === ‘)’) { if (left.length > 0) {

   stack[i] = 1;
   stack[left.pop()] = 1;
  

  } else {

   stack[i] = 0;
  

  } } else { left.push(i); } }

  let maxLen = 0; let count = 0; for(let num of stack) { num && count++; !num && (count = 0); maxLen = Math.max(maxLen, count); } return maxLen; }; ``` | | —- |

20220405，13min

| 20220405```javascript /**

• @param {string} s

• @return {number} */ // 10:02 -> 10:15 // 栈，下标 var longestValidParentheses = function(s) { let maxLen = 0; let valid = new Array(s.length).fill(0); let stack = []; for (let i = 0; i < s.length; i++) { if (s[i] === ‘(‘) { stack.push(i); } else if (stack.length) {

   valid[i] = 1;
   valid[stack.pop()] = 1;
  

  } }

  let count = 0; for (let n of valid) { n && count++; !n && (count = 0); maxLen = Math.max(maxLen, count); } return maxLen }; ``` | | —- |

20220403，不通过

| 20220403```javascript /**

• @param {string} s

• @return {number} */ // 15:38 -> 16：11 // 循环，如果是’()’，放入数组，如果不是，计算数组长度，与原先maxLen比较，留下大的值，然后清空数组 // i, i + 1：（）(放入数组)、((、)(、))

  // 栈 // 如果是左括号，入栈，如果是右括号，匹配栈中是否有左括号，若有，左括号出栈，并maxLen+1，若没有，maxLen与原先的比较 var longestValidParentheses = function(s) { // let arr = []; // for (let i = 0; i < s.length; i++) { // if (s[i] === ‘(‘ && s[i + 1] === ‘)’) { // arr.push(‘()’); // } // }

  let stack = []; let maxLen = 0; let len = 0; for(let str of s) { if (str === ‘(‘) { stack.push(‘(‘) } else { if (stack.length > 0) { // 是’)’，并且栈中有’(‘与之匹配

   // len += 1; // bug：如果有()，这是一对，是2个子串
   len += 2;
   maxLen = Math.max(maxLen, len);
   stack.pop();
  

  } else {

   stack = [];
   maxLen = Math.max(maxLen, len);
   len = 0;
  

  } } } // bug:忘记把结果return出来了 return maxLen; }; ``` 不通过，如果输入’()(()’，输出4，预期结果2
  知识点
  - 忘记考虑(())的情况了，只是(入栈，看有没有）匹配的话，不能剔除(())这种情况
  | | —- |