leetcode 32. Longest Valid Parentheses スタック法

Author: myoshi2891

Algorithm/DynamicProgramming/leetcode/32. Longest Valid Parentheses/Longest-Valid-Parentheses.ts

@@ -0,0 +1,74 @@
+// 以下は、指定された問題に対する **TypeScript (5.1) + Node.js 18.16.1** 向けの **DP（動的計画法）版の解法** です。クラスは使わず、**関数ベース**で記述し、**LeetCodeの効率**も意識してあります。
+
+// ---
+
+// ### ✅ アルゴリズム概要（DP法）
+
+// * `dp[i]` を「`i` 番目の文字を終点とする最長の有効な括弧の長さ」と定義します。
+// * `s[i] === ')'` であり、`s[i - 1] === '('` の場合 → `dp[i] = dp[i - 2] + 2`
+// * `s[i] === ')'` であり、`s[i - 1] === ')'` の場合は、`s[i - dp[i - 1] - 1] === '('` を確認してペアを拡張
+
+// ---
+
+// ### ✅ TypeScript 実装
+
+// ```typescript
+/**
+ * 最長の有効な括弧部分文字列の長さを返す（DP法）
+ *
+ * @param s - '(' と ')' のみからなる文字列
+ * @returns 最長の well-formed な部分文字列の長さ
+ */
+function longestValidParenthesesDP(s: string): number {
+  const n: number = s.length;
+  const dp: number[] = new Array(n).fill(0);
+  let maxLength: number = 0;
+
+  for (let i = 1; i < n; i++) {
+    if (s[i] === ')') {
+      if (s[i - 1] === '(') {
+        // 直前が '(', 対応ペアなので +2
+        dp[i] = (i >= 2 ? dp[i - 2] : 0) + 2;
+      } else if (i - dp[i - 1] - 1 >= 0 && s[i - dp[i - 1] - 1] === '(') {
+        // 直前も ')', さらにその前に対応する '(' がある
+        dp[i] = dp[i - 1] + 2;
+        if (i - dp[i - 1] - 2 >= 0) {
+          dp[i] += dp[i - dp[i - 1] - 2]; // 前の連結部分も足す
+        }
+      }
+      maxLength = Math.max(maxLength, dp[i]);
+    }
+  }
+
+  return maxLength;
+}
+// ```
+
+// ---
+
+// ### ✅ 使用例
+
+// ```typescript
+// console.log(longestValidParentheses("(()"));      // 2
+// console.log(longestValidParentheses(")()())"));   // 4
+// console.log(longestValidParentheses(""));         // 0
+// console.log(longestValidParentheses("()(()"));    // 2
+// console.log(longestValidParentheses("()()"));     // 4
+// ```
+
+// ---
+
+// ### ✅ 時間・空間計算量
+
+// | 指標      | 値                     |
+// | ------- | --------------------- |
+// | 時間計算量   | O(n)                  |
+// | 空間計算量   | O(n) （dp 配列使用）        |
+// | 実行時間目安  | 約 60ms〜80ms（LeetCode） |
+// | メモリ使用目安 | 約 45MB〜50MB（LeetCode） |
+
+// ---
+
+// DP法は**スタック法よりもややメモリ使用量が多め**ですが、括弧の構造を明示的に覚えて拡張していくため、構文解析に近い用途では有効です。
+
+// ご希望があれば、**空間O(1)の両方向スキャン解法**も提供できます。

Algorithm/Two-passScanMethod/leetcode/32. Longest Valid Parentheses/Longest-Valid-Parentheses.py

@@ -0,0 +1,122 @@
+# O(1) 追加メモリで最長有効括弧長を求める方法は、
+# **左右 2 回のスキャン法（two-pass scan method）** を使います。
+
+# ---
+
+# ## **アルゴリズムの概要**
+
+# 1. **左→右スキャン**
+
+#    * `left` カウント: '(' の数
+#    * `right` カウント: ')' の数
+#    * `left == right` の時点で長さ `2 * right` が有効
+#    * `right > left` になったらリセット（`(` より `)` が多くなったので無効）
+
+# 2. **右→左スキャン**
+
+#    * `left` カウント: '(' の数
+#    * `right` カウント: ')' の数
+#    * 逆方向で同様にカウント
+#    * 今度は `left > right` でリセット
+#    * これにより `)` が先行する場合も検出可能
+
+# ---
+
+# ### **Python (CPython 3.11.4) 実装例**
+
+# ```python
+class Solution:
+    def longestValidParentheses(self, s: str) -> int:
+        """
+        O(1) 追加メモリ版
+        パラメータ:
+            s (str): '(' と ')' のみからなる文字列
+        戻り値:
+            int: 最長の有効な括弧部分文字列の長さ
+
+        計算量:
+            時間計算量 O(n)
+            空間計算量 O(1) 追加メモリ
+        """
+        max_len: int = 0
+        left: int = 0
+        right: int = 0
+
+        # 1. 左→右スキャン
+        for ch in s:
+            if ch == '(':
+                left += 1
+            else:
+                right += 1
+
+            if left == right:
+                max_len = max(max_len, 2 * right)
+            elif right > left:
+                left = right = 0
+
+        # 2. 右→左スキャン
+        left = right = 0
+        for ch in reversed(s):
+            if ch == '(':
+                left += 1
+            else:
+                right += 1
+
+            if left == right:
+                max_len = max(max_len, 2 * left)
+            elif left > right:
+                left = right = 0
+
+        return max_len
+
+
+# 動作確認
+if __name__ == "__main__":
+    solver = Solution()
+    test_cases = ["(()", ")()())", "", "()(())", "())((())"]
+    for s in test_cases:
+        print(f"Input: {s!r}, Output: {solver.longestValidParentheses(s)}")
+
+# ### **実行結果例**
+
+# ```
+# Input: '(()', Output: 2
+# Input: ')()())', Output: 4
+# Input: '', Output: 0
+# Input: '()(())', Output: 6
+# Input: '())((())', Output: 4
+# ```
+
+# ---
+
+# ### **処理時間・メモリ消費量**
+
+# * **時間計算量**:
+
+#   * 左右スキャンで **O(n)**
+
+# * **空間計算量**:
+
+#   * カウンタ変数のみ → **O(1)**
+
+# * **メモリ使用量目安**:
+
+#   * 追加メモリほぼゼロ（数個の int のみ）
+
+# ---
+
+# ### **メリット・デメリット**
+
+# * ✅ メモリ効率が非常に良い（スタック不要）
+# * ✅ 2 パスなので比較的実装がシンプル
+# * ⚠️ 実際のインデックス位置を復元するのは難しい（長さのみ計算向け）
+
+# ---
+
+# 質問です。
+# この問題を **LeetCode で提出**する場合、あなたは
+
+# 1. **O(1) メモリの最適版**を提出して高速化したい
+# 2. **O(n) スタック法**のほうがバグ少なく安心
+
+# どちらを優先したいですか？

Algorithm/Two-passScanMethod/leetcode/32. Longest Valid Parentheses/Longest-Valid-Parentheses.ts

@@ -0,0 +1,33 @@
+function longestValidParenthesesO1(s: string): number {
+    let left = 0;
+    let right = 0;
+    let maxLen = 0;
+
+    // 左→右
+    for (const ch of s) {
+        if (ch === '(') left++;
+        else right++;
+        if (left === right) maxLen = Math.max(maxLen, 2 * right);
+        else if (right > left) left = right = 0;
+    }
+
+    left = 0;
+    right = 0;
+
+    // 右→左
+    for (let i = s.length - 1; i >= 0; i--) {
+        const ch = s[i];
+        if (ch === '(') left++;
+        else right++;
+        if (left === right) maxLen = Math.max(maxLen, 2 * left);
+        else if (left > right) left = right = 0;
+    }
+
+    return maxLen;
+}
+
+// 動作確認
+// const testCases = [')()())', '(()', '()(())', '())((())'];
+for (const s of testCases) {
+    console.log(`Input: '${s}', Output: ${longestValidParenthesesO1(s)}`);
+}