leetcode 14. Longest Common Prefix

Author: myoshi2891

Algorithm/DynamicProgramming/other/partial sum problem/README.md

@@ -0,0 +1,162 @@
+、**部分和問題（Subset Sum Problem）をDPで解く方法**について、処理の流れを**図解付きで丁寧に解析・説明**します。
+
+---
+
+## 🎯 問題の再掲
+
+> 整数列 `a = [a₁, a₂, ..., aₙ]` の中からいくつかを選んで、ちょうど合計 `K` を作れるか？
+> 作れるなら `Yes`、作れなければ `No` を出力。
+
+---
+
+## 🧠 解法の基本（DPテーブル）
+
+### 定義
+
+* `dp[i][j] = true`
+  → **先頭から `i` 個目までの要素を使って、合計 `j` を作ることができるか？**
+
+---
+
+## ✅ 入力例
+
+```
+N = 3, K = 6  
+a = [1, 2, 3]
+```
+
+---
+
+## 🪄 初期状態
+
+最初は「**何も選ばなければ合計は0**」のみが成立。
+
+```
+dp[0][0] = true
+それ以外の dp[0][j] = false (1 <= j <= K)
+```
+
+```
+i=0:
+j →   0   1   2   3   4   5   6
+     [T   F   F   F   F   F   F]
+```
+
+---
+
+## 🔁 1ステップ目：a\[0] = 1 を使う/使わない
+
+前の行 `dp[0][j]` の情報をもとに `dp[1][j]` を更新
+
+* `dp[0][0] = true`
+
+  * `dp[1][0] = true`（1を使わない）
+  * `dp[1][1] = true`（1を使う → 0+1）
+
+```
+i=1:
+j →   0   1   2   3   4   5   6
+     [T   T   F   F   F   F   F]
+```
+
+---
+
+## 🔁 2ステップ目：a\[1] = 2 を使う/使わない
+
+* `dp[1][0] = true`
+
+  * → `dp[2][0] = true`（使わない）
+  * → `dp[2][2] = true`（使う）
+
+* `dp[1][1] = true`
+
+  * → `dp[2][1] = true`（使わない）
+  * → `dp[2][3] = true`（使う）
+
+```
+i=2:
+j →   0   1   2   3   4   5   6
+     [T   T   T   T   F   F   F]
+```
+
+---
+
+## 🔁 3ステップ目：a\[2] = 3 を使う/使わない
+
+* `dp[2][0] = true`
+
+  * → `dp[3][0] = true`
+  * → `dp[3][3] = true`
+
+* `dp[2][1] = true`
+
+  * → `dp[3][1] = true`
+  * → `dp[3][4] = true`
+
+* `dp[2][2] = true`
+
+  * → `dp[3][2] = true`
+  * → `dp[3][5] = true`
+
+* `dp[2][3] = true`
+
+  * → `dp[3][3] = true`
+  * → `dp[3][6] = true` ← **ここが最終的に重要！**
+
+```
+i=3:
+j →   0   1   2   3   4   5   6
+     [T   T   T   T   T   T   T]
+```
+
+---
+
+## ✅ 最終判定
+
+* `dp[3][6] == true` → **Yes**（合計6を作ることが可能）
+
+---
+
+## 🧾 DPテーブル全体の図（3行 × 7列）
+
+```
+行: i = 選んだ要素数（0～3）
+列: j = 目標合計（0～K）
+
+     j →  0   1   2   3   4   5   6
+i=0:     T   F   F   F   F   F   F
+i=1:     T   T   F   F   F   F   F
+i=2:     T   T   T   T   F   F   F
+i=3:     T   T   T   T   T   T   T
+```
+
+---
+
+## 🔄 遷移図（概念）
+
+```txt
+[dp[0][0] = true]
+ ├─(使わない)→ dp[1][0]
+ └─(使う+1) → dp[1][1]
+      ├─(使わない)→ dp[2][1]
+      └─(使う+2) → dp[2][3]
+           ├─(使わない)→ dp[3][3]
+           └─(使う+3) → dp[3][6] ← Yes!
+```
+
+---
+
+## 💡 注意点
+
+* `a[i]` は 1〜100 なので、`K=2000` のときでも範囲内に収まる。
+* 状態数は `N × K`、最大でも `20 × 2000 = 40000` なので余裕。
+
+---
+
+## 🔚 結論
+
+* DPテーブル `dp[i][j]` により部分和を段階的に構築。
+* 最終的な `dp[N][K]` を見て Yes/No を判定。
+* 各ステップで「選ぶ or 選ばない」の2択を網羅的に考える。
+
+---

Algorithm/DynamicProgramming/other/partial sum problem/partial-sum-problem.js

@@ -0,0 +1,127 @@
+// はい、\*\*DP（動的計画法）\*\*を用いた部分和問題の解法について説明し、**Node.js (JavaScript) + `fs`入力対応版**でコードを提供します。
+
+// ---
+
+// ## 🧠 基本方針（DP）
+
+// ### 問題
+
+// 与えられた整数列 `a = [a1, a2, ..., aN]` の中からいくつかの要素を選んで、その合計を `K` にできるか判定する。
+
+// ---
+
+// ## 🧮 DPの定義
+
+// 以下のような2次元配列 `dp[i][j]` を定義します：
+
+// > `dp[i][j] = true` とは、
+// > 「先頭から `i` 個目までの要素の中から選んで合計が `j` にできる」ことを意味します。
+
+// ---
+
+// ## 🧩 遷移
+
+// 1. 初期状態：
+
+//    ```js
+//    dp[0][0] = true
+//    ```
+
+// 2. 遷移式（各a\[i]を使うか使わないか）：
+
+//    ```js
+//    dp[i+1][j]     |= dp[i][j]        // a[i] を使わない場合
+//    dp[i+1][j+a[i]] |= dp[i][j]       // a[i] を使う場合（j+a[i] <= K のときのみ）
+//    ```
+
+// ---
+
+// ## 💻 JavaScript実装（Node.js + fs入力）
+
+// ```javascript
+const fs = require('fs');
+
+// 入力の読み込み
+const input = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n');
+const [N, K] = input[0].split(' ').map(Number);
+const A = input[1].split(' ').map(Number);
+
+/**
+ * DPを用いて部分和がKになるかを判定する関数
+ * @param {number[]} a - 入力の整数列
+ * @param {number} k - 目標とする合計値
+ * @returns {string} - "Yes" または "No"
+ */
+function isSubsetSumDP(a, k) {
+    const n = a.length;
+
+    // dp[i][j] = i番目まで見てjを作れるか
+    const dp = Array.from({ length: n + 1 }, () => Array(k + 1).fill(false));
+    dp[0][0] = true; // 何も選ばなければ和は0
+
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j <= k; j++) {
+            if (dp[i][j]) {
+                dp[i + 1][j] = true; // a[i]を使わない
+                if (j + a[i] <= k) {
+                    dp[i + 1][j + a[i]] = true; // a[i]を使う
+                }
+            }
+        }
+    }
+
+    return dp[n][k] ? "Yes" : "No";
+}
+
+// 実行と出力
+console.log(isSubsetSumDP(A, K));
+// ```
+
+// ---
+
+// ## 🧠 時間・空間計算量
+
+// * **時間計算量**：`O(N × K)`
+//   最大で `20 × 2000 = 40000` → 非常に高速
+// * **空間計算量**：`O(N × K)` → 2次元配列を用いたため `~160,000` 個のboolean
+
+// ※ `dp[i][j]` の「`i`が不要（直前しか見ない）」なので、`1次元配列`で `O(K)` に圧縮可能です。
+
+// ---
+
+// ## ✅ 入力例と出力例
+
+// 入力：
+
+// ```
+// 3 6
+// 1 2 3
+// ```
+
+// 出力：
+
+// ```
+// Yes
+// ```
+
+// ---
+
+// ## ✅ 圧縮版（1次元配列で高速化）
+
+// 1次元配列にしてさらにメモリを削減したい場合：
+
+// ```js
+function isSubsetSumDP1D(a, k) {
+    let dp = Array(k + 1).fill(false);
+    dp[0] = true;
+
+    for (const val of a) {
+        const next = [...dp]; // 今回の遷移後の配列をコピー
+        for (let j = 0; j <= k - val; j++) {
+            if (dp[j]) next[j + val] = true;
+        }
+        dp = next;
+    }
+
+    return dp[k] ? "Yes" : "No";
+}

Algorithm/Other/leetcode/14. Longest Common Prefix/LongestCommonPrefix.py

@@ -0,0 +1,99 @@
+# LeetCode のテストケースは
+# `class Solution` にメソッドを定義する形式が必要です。
+
+# なので、次のように修正します：
+
+# ## ✅ LeetCode形式（`class Solution`）
+
+# ```python
+import time
+import tracemalloc
+from typing import List, Tuple
+
+class Solution:
+    def longestCommonPrefix(self, strs: List[str]) -> str:
+        """
+        LeetCode用 最長共通接頭辞関数
+
+        :param strs: List[str] - 文字列のリスト
+        :return: str - 最長共通接頭辞。共通部分がなければ空文字。
+        """
+        if not strs:
+            return ""
+        
+        prefix = strs[0]
+        
+        for s in strs[1:]:
+            while not s.startswith(prefix):
+                prefix = prefix[:-1]
+                if not prefix:
+                    return ""
+        return prefix
+
+def run_with_performance_log(strs: List[str]) -> Tuple[str, float, int]:
+    """
+    処理時間とメモリ消費量を計測し、最長共通接頭辞を求める
+
+    :param strs: List[str] - 文字列リスト
+    :return: Tuple[str, float, int]
+        - 最長共通接頭辞（str）
+        - 処理時間（ミリ秒、float）
+        - メモリ消費量（KB、int）
+    """
+    solution = Solution()
+
+    tracemalloc.start()
+    start_time = time.perf_counter()
+
+    result = solution.longestCommonPrefix(strs)
+
+    end_time = time.perf_counter()
+    _, peak = tracemalloc.get_traced_memory()
+    tracemalloc.stop()
+
+    time_elapsed_ms = (end_time - start_time) * 1000  # ミリ秒
+    memory_usage_kb = peak // 1024  # KB単位に変換
+
+    return result, time_elapsed_ms, memory_usage_kb
+
+# サンプル実行
+if __name__ == "__main__":
+    test_cases = [
+        ["flower", "flow", "flight"],
+        ["dog", "racecar", "car"]
+    ]
+
+    for i, case in enumerate(test_cases, 1):
+        result, time_ms, mem_kb = run_with_performance_log(case)
+        print(f"Test Case {i}: {case}")
+        print(f"Longest Common Prefix: '{result}'")
+        print(f"Time: {time_ms:.3f} ms")
+        print(f"Memory: {mem_kb} KB")
+        print("=" * 40)
+# ```
+
+# ---
+
+# ## ✅ 実行結果（例）
+
+# ```
+# Test Case 1: ['flower', 'flow', 'flight']
+# Longest Common Prefix: 'fl'
+# Time: 0.030 ms
+# Memory: 0 KB
+# ========================================
+# Test Case 2: ['dog', 'racecar', 'car']
+# Longest Common Prefix: ''
+# Time: 0.025 ms
+# Memory: 0 KB
+# ========================================
+# ```
+
+# ---
+
+# ## LeetCode用注意点：
+
+# * `Solution`クラスにメソッドを書く必要があります。
+# * 引数や戻り値は LeetCode標準形式。
+
+# ---