From 603506c356a9fe8ae3e06b585873a6007e59055c Mon Sep 17 00:00:00 2001
From: myoshizumi <myoshizumi@alumni.berklee.edu>
Date: Sun, 13 Jul 2025 12:12:25 +0900
Subject: [PATCH 1/2] atcoder B19 - Knapsack 2 DP

---
 .../atCoder/Knapsack DP/B19/B19.go            | 125 +++++++++++
 .../atCoder/Knapsack DP/B19/B19.js            |  75 +++++++
 .../atCoder/Knapsack DP/B19/B19.php           | 119 ++++++++++
 .../atCoder/Knapsack DP/B19/B19.py            | 123 +++++++++++
 .../atCoder/Knapsack DP/B19/B19.ts            |  99 +++++++++
 .../atCoder/Knapsack DP/B19/README.md         | 209 ++++++++++++++++++
 6 files changed, 750 insertions(+)
 create mode 100644 Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/B19.go
 create mode 100644 Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/B19.js
 create mode 100644 Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/B19.php
 create mode 100644 Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/B19.py
 create mode 100644 Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/B19.ts
 create mode 100644 Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/README.md

diff --git a/Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/B19.go b/Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/B19.go
new file mode 100644
index 00000000..ee78545c
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/B19.go	
@@ -0,0 +1,125 @@
+// 以下は、**Go 1.20.6** における `Knapsack 2（価値軸DP）` の実装です。
+// **型の明示・関数の分割・処理時間とメモリの効率を考慮**した構成になっています。
+
+// ## ✅ 構成と特徴
+
+// | 関数名               | 役割           | 引数 / 返却値                     |
+// | ----------------- | ------------ | ---------------------------- |
+// | `parseInput()`    | 入力をパース       | `() → (int, int, [][2]int)`  |
+// | `solveKnapsack()` | DPにより最大価値を計算 | `(int, int, [][2]int) → int` |
+// | `main()`          | 入出力をまとめて呼び出す | `なし`                         |
+
+// ## ✅ Go 実装（`Go 1.20.6` 準拠、コメント付き）
+
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"math"
+	"os"
+	"strconv"
+	"strings"
+)
+
+// parseInput は標準入力から N, W, items を読み取って返します。
+// 戻り値: (品物数, 容量W, 品物リスト(重さ, 価値))
+func parseInput() (int, int, [][2]int) {
+	scanner := bufio.NewScanner(os.Stdin)
+	scanner.Scan()
+	header := strings.Fields(scanner.Text())
+	N, _ := strconv.Atoi(header[0])
+	W, _ := strconv.Atoi(header[1])
+
+	items := make([][2]int, N)
+	for i := 0; i < N && scanner.Scan(); i++ {
+		parts := strings.Fields(scanner.Text())
+		w, _ := strconv.Atoi(parts[0])
+		v, _ := strconv.Atoi(parts[1])
+		items[i] = [2]int{w, v}
+	}
+	return N, W, items
+}
+
+// solveKnapsack は価値軸DPにより、重さ制限W以下で得られる最大価値を計算します。
+// 引数: 品物数N、容量W、品物(重さ, 価値)
+// 戻り値: 最大の価値
+func solveKnapsack(N int, W int, items [][2]int) int {
+	// 最大の価値合計を取得（DP配列サイズの上限）
+	maxValue := 0
+	for _, item := range items {
+		maxValue += item[1]
+	}
+
+	const INF = math.MaxInt64
+	dp := make([]int, maxValue+1)
+	for i := range dp {
+		dp[i] = INF
+	}
+	dp[0] = 0
+
+	for _, item := range items {
+		w, v := item[0], item[1]
+		for val := maxValue; val >= v; val-- {
+			if dp[val-v] != INF && dp[val-v]+w < dp[val] {
+				dp[val] = dp[val-v] + w
+			}
+		}
+	}
+
+	// dp[v] <= W となる最大の v を探す
+	for v := maxValue; v >= 0; v-- {
+		if dp[v] <= W {
+			return v
+		}
+	}
+	return 0
+}
+
+func main() {
+	N, W, items := parseInput()
+	result := solveKnapsack(N, W, items)
+	fmt.Println(result)
+}
+// ## ✅ 入力例（例: input.txt）
+
+// ```
+// 4 7
+// 3 13
+// 3 17
+// 5 29
+// 1 10
+// ```
+
+// ### 実行方法：
+
+// ```bash
+// go run main.go < input.txt
+// ```
+
+// ---
+
+// ## ✅ 計算量・メモリ見積り
+
+// | 項目     | 内容                                |
+// | ------ | --------------------------------- |
+// | 計算量    | `O(N × sum_v)` = `1e7` 程度         |
+// | メモリ使用量 | `dp[]` 約 `100000 × 8byte ≒ 800KB` |
+// | 実行時間目安 | 数百ms〜1秒以内                         |
+// | 制限     | 時間：10秒 / メモリ：1024MiB              |
+
+// ---
+
+// ## ✅ Go の注意点
+
+// * `math.MaxInt64` を使って `INF` を表現
+// * `dp` は 64bit int のスライス（int は通常 64bit）
+// * 入力は `bufio.Scanner` + `strings.Fields` で高速処理
+
+// ---
+
+// ## ✅ 拡張可能な内容
+
+// * 選んだ品物の復元
+// * メモリ圧縮（必要なら複数スライス併用）
+// * 時間軸DP（Wが小さいときに有効）
diff --git a/Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/B19.js b/Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/B19.js
new file mode 100644
index 00000000..1dfc75c6
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/B19.js	
@@ -0,0 +1,75 @@
+// 以下は、Node.js 18.16.1 環境で `fs` モジュールを使って解く、\*\*「Knapsack 2（DP with value）」\*\*問題の解法です。
+
+// この問題では `W ≤ 10^9` と非常に大きいので、「重さ」を軸にしたDPではメモリが足りません。代わりに **価値を軸にしたDP（value-based DP）** を使います。
+
+// ---
+
+// ### ✅ 解法の概要（価値DP）
+
+// * `dp[v] = w`: 価値の合計が `v` のときの最小重さ `w`
+// * 初期値: `dp[0] = 0`, それ以外は `Infinity`
+// * 全ての品物に対して `dp` を更新
+// * 最終的に、`dp[v] <= W` となる最大の `v` を答えとする
+
+// ---
+
+// ### ✅ 実装（コメント付き、`fs`使用）
+
+// ```javascript
+// Node.js (v18.16.1) 用
+const fs = require("fs");
+
+// 入力の読み取り
+const input = fs.readFileSync("/dev/stdin", "utf8").trim().split("\n");
+const [N, W] = input[0].split(" ").map(Number);
+const items = input.slice(1).map(line => {
+  const [w, v] = line.split(" ").map(Number);
+  return { w, v };
+});
+
+// 最大価値の合計（各価値最大1000 × N）
+const maxValue = items.reduce((sum, item) => sum + item.v, 0);
+
+// dp[v] := 価値の合計がvのときの最小重量（初期はInfinity）
+const dp = new Array(maxValue + 1).fill(Infinity);
+dp[0] = 0; // 価値0のときの重量は0
+
+// 品物を1つずつ見てDPを更新
+for (let i = 0; i < N; i++) {
+  const { w, v } = items[i];
+
+  // 逆順に更新することで「1つの品物を1回だけ使う」制約を守る
+  for (let value = maxValue; value >= v; value--) {
+    if (dp[value - v] + w <= W) {
+      dp[value] = Math.min(dp[value], dp[value - v] + w);
+    }
+  }
+}
+
+// dp[v] <= W を満たす最大の v を探す
+let result = 0;
+for (let v = 0; v <= maxValue; v++) {
+  if (dp[v] <= W) {
+    result = v;
+  }
+}
+
+console.log(result);
+
+/*
+返却値: console.log(result)
+ - 条件を満たす中で最大の価値合計 v を出力します。
+ - 計算量: O(N * maxValue) ≈ 100 × 100000 = 1e7（制限内）
+ - メモリ: 約 maxValue 分（数MB程度）
+*/
+
+// ### ✅ 実行時間・メモリ見積り
+
+// * **計算量**: `O(N * sum_v)` = `100 × 100000` = `1e7`（高速）
+// * **メモリ使用量**: `dp[]` = 約 `100001 × 4bytes` ≒ 約400KB（問題の上限1GBの範囲内）
+
+// ### ✅ 備考
+
+// * 「Wが大きすぎる」＝重さでDP配列を作るのは不適
+// * 品物の**価値を基準**にDPするのが典型解
+// * `O(N×価値合計)` なので、今回のように **価値 ≤ 1000 × N** のとき有効
diff --git a/Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/B19.php b/Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/B19.php
new file mode 100644
index 00000000..8b0808c3
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/B19.php	
@@ -0,0 +1,119 @@
+<!-- 以下は、**PHP 8.2.8** を使用して、**Knapsack 2（価値軸DP）** を解くための実装です。
+
+## ✅ 特徴
+
+* **関数分割済み**
+* **引数と戻り値の型指定**
+* **処理時間・メモリ制約（10秒・1024MiB）を考慮**
+* `int` 型は PHP 内部で 64bit まで扱える（W = 1e9 に対応可能）
+
+## ✅ 使用関数一覧と説明
+
+| 関数名               | 説明                | パラメータ・返却値                                                        |
+| ----------------- | ----------------- | ---------------------------------------------------------------- |
+| `parseInput()`    | 標準入力からデータを取得して構造化 | 戻り値: `array{int, int, array<array{int, int}>}`                   |
+| `solveKnapsack()` | DP配列で最大の価値を計算     | 引数: `int $N, int $W, array<array{int,int}> $items`<br>返り値: `int` |
+| `main()`          | 全体統括（入出力）         | 戻り値: `void`                                                      |
+
+---
+
+## ✅ PHPコード（PHP 8.2.8）
+
+<?php
+
+/**
+ * 標準入力から値を読み込み、品物情報を構造化して返す
+ *
+ * @return array{int, int, array<array{int, int}>} [N, W, items]
+ */
+function parseInput(): array {
+    $lines = explode("\n", trim(file_get_contents("php://stdin")));
+    [$N, $W] = array_map('intval', explode(' ', array_shift($lines)));
+    $items = [];
+
+    foreach ($lines as $line) {
+        [$w, $v] = array_map('intval', explode(' ', $line));
+        $items[] = [$w, $v]; // [重さ, 価値]
+    }
+
+    return [$N, $W, $items];
+}
+
+/**
+ * ナップザック問題を価値軸DPで解き、最大の価値を返す
+ *
+ * @param int $N 品物数
+ * @param int $W ナップサック容量
+ * @param array<array{int, int}> $items 品物の [重さ, 価値] の配列
+ * @return int 容量W以下で得られる最大の価値
+ */
+function solveKnapsack(int $N, int $W, array $items): int {
+    $maxValue = 0;
+    foreach ($items as [$w, $v]) {
+        $maxValue += $v;
+    }
+
+    $INF = PHP_INT_MAX;
+    $dp = array_fill(0, $maxValue + 1, $INF);
+    $dp[0] = 0;
+
+    foreach ($items as [$w, $v]) {
+        for ($val = $maxValue; $val >= $v; --$val) {
+            if ($dp[$val - $v] !== $INF && $dp[$val - $v] + $w <= $W) {
+                $dp[$val] = min($dp[$val], $dp[$val - $v] + $w);
+            }
+        }
+    }
+
+    // dp[v] <= W を満たす最大の v を探す
+    for ($v = $maxValue; $v >= 0; --$v) {
+        if ($dp[$v] <= $W) {
+            return $v;
+        }
+    }
+
+    return 0;
+}
+
+/**
+ * メイン関数：標準入力を読み取り、解を出力
+ *
+ * @return void
+ */
+function main(): void {
+    [$N, $W, $items] = parseInput();
+    $result = solveKnapsack($N, $W, $items);
+    echo $result . PHP_EOL;
+}
+
+main();
+
+// ## ✅ 入力例（input.txt）
+
+// ```
+// 4 7
+// 3 13
+// 3 17
+// 5 29
+// 1 10
+// ```
+
+// ### 実行方法
+
+// ```bash
+// php main.php < input.txt
+// ```
+
+// ## ✅ 計算量・メモリ見積もり
+
+// | 指標     | 値                                    |
+// | ------ | ------------------------------------ |
+// | 時間計算量  | `O(N × sum_v)` ≈ 100 × 100000 = 10^7 |
+// | メモリ使用量 | 約 400 KB（dp配列：100001 × 8バイト）         |
+// | 実行時間   | 数百ミリ秒〜1秒以下（十分高速）                     |
+// | メモリ制限  | 1024 MiB 制限内に収まる                     |
+
+// ## ✅ 補足
+
+// * PHPは `array` 型が柔軟なので、型アノテーションをコメントで補っています。
+// * より厳格な型検査をしたい場合は [Psalm](https://psalm.dev/) のような静的解析ツールも有効です。
\ No newline at end of file
diff --git a/Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/B19.py b/Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/B19.py
new file mode 100644
index 00000000..7b174571
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/B19.py	
@@ -0,0 +1,123 @@
+# 以下は、**Python (CPython 3.11.4)** を使用して、**Knapsack 2（価値軸DP）** を解く実装です。関数を分割し、**型アノテーション付き**で、**処理時間・メモリの効率にも配慮**しています。
+
+# ---
+
+# ## ✅ 構成と特徴
+
+# | 関数名                | 役割          | 返却値                                      |
+# | ------------------ | ----------- | ---------------------------------------- |
+# | `parse_input()`    | 入力パース処理     | `tuple[int, int, list[tuple[int, int]]]` |
+# | `solve_knapsack()` | DPによる最大価値計算 | `int`（価値の最大値）                            |
+# | `main()`           | 入出力処理       | `None`（標準出力）                             |
+
+# ---
+
+# ## ✅ Python 実装（関数分割 + コメント付き）
+
+# ```python
+import sys
+from typing import List, Tuple
+
+def parse_input() -> Tuple[int, int, List[Tuple[int, int]]]:
+    """
+    入力をパースして返す関数
+
+    Returns:
+        N (int): 品物数
+        W (int): ナップサックの容量
+        items (List[Tuple[int, int]]): 各品物の (重さ, 価値) のリスト
+    """
+    lines = sys.stdin.read().strip().split('\n')
+    N, W = map(int, lines[0].split())
+    items: List[Tuple[int, int]] = [
+        (int(w), int(v)) for w, v in (line.split() for line in lines[1:])
+    ]
+    return N, W, items
+
+def solve_knapsack(N: int, W: int, items: List[Tuple[int, int]]) -> int:
+    """
+    ナップザック問題を価値軸DPで解く
+
+    Args:
+        N (int): 品物数
+        W (int): ナップサック容量
+        items (List[Tuple[int, int]]): 各品物の (重さ, 価値)
+
+    Returns:
+        int: 容量 W 以下で達成可能な最大の価値
+    """
+    max_value = sum(v for _, v in items)
+    INF = float('inf')
+    dp: List[float] = [INF] * (max_value + 1)
+    dp[0] = 0  # 価値0に必要な重さは0
+
+    for w, v in items:
+        for val in range(max_value, v - 1, -1):
+            if dp[val - v] + w <= W:
+                dp[val] = min(dp[val], dp[val - v] + w)
+
+    # dp[v] <= W を満たす最大の v を返す
+    for val in range(max_value, -1, -1):
+        if dp[val] <= W:
+            return val
+    return 0
+
+
+def main() -> None:
+    """
+    メイン関数：標準入力から読み取り、最大価値を出力
+
+    Returns:
+        None
+    """
+    N, W, items = parse_input()
+    result = solve_knapsack(N, W, items)
+    print(result)
+
+
+if __name__ == "__main__":
+    main()
+# ```
+
+# ---
+
+# ## ✅ 実行例
+
+# ```bash
+# python3 main.py < input.txt
+# ```
+
+# ---
+
+# ## ✅ 計算量・メモリ見積もり
+
+# | 指標     | 内容                                     |
+# | ------ | -------------------------------------- |
+# | 時間計算量  | O(N × max\_value) = 100 × 100000 ≒ 1e7 |
+# | メモリ使用量 | dp\[100001] × 8バイト ≒ 約 800 KB          |
+# | 実行時間制限 | 10 秒以内（通常 0.1～0.5秒で終了）                 |
+# | メモリ制限  | 1024 MiB（このコードは余裕あり）                   |
+
+# ---
+
+# ## ✅ 処理ステップ図（概要）
+
+# ```text
+# 標準入力 → parse_input()
+#               ↓
+#           N, W, items
+#               ↓
+#        solve_knapsack()  ← DPテーブル生成
+#               ↓
+#            最大価値を算出
+#               ↓
+#            print(result)
+# ```
+
+# ---
+
+# ## ✅ 拡張案（必要なら）
+
+# * 品物選択の **経路復元（どの品物を選んだか）**
+# * 重さ軸DP（Wが小さい場合のみ有効）
+# * メモリ最適化（1次元DP）
diff --git a/Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/B19.ts b/Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/B19.ts
new file mode 100644
index 00000000..4d1e2da9
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/B19.ts	
@@ -0,0 +1,99 @@
+// はい、TypeScript で関数を分割し、それぞれに明確な役割と返却値のコメントを付けた形で整理可能です。
+// 以下に、処理を **3つの関数** に分けた構造化された解法を示します：
+
+// ### ✅ 関数構成
+
+// | 関数名             | 役割             | 返却値               |
+// | --------------- | -------------- | ----------------- |
+// | `parseInput`    | 入力文字列からデータをパース | `{ N, W, items }` |
+// | `solveKnapsack` | DPで最大価値を計算     | `number`（最大価値）    |
+// | `main`          | 入出力処理および全体制御   | `void`（出力のみ）      |
+
+// ### ✅ TypeScript コード（構造化 + コメント付き）
+
+// ```ts
+import * as fs from 'fs';
+
+// 品物の型定義
+type Item = { w: number; v: number };
+
+/**
+ * 標準入力からのデータをパースする
+ * @param input 入力文字列（複数行）
+ * @returns 品物数N、容量W、品物配列items
+ */
+function parseInput(input: string): { N: number; W: number; items: Item[] } {
+  const lines = input.trim().split('\n');
+  const [N, W] = lines[0].split(' ').map(Number);
+  const items: Item[] = lines.slice(1).map(line => {
+    const [w, v] = line.split(' ').map(Number);
+    return { w, v };
+  });
+  return { N, W, items };
+}
+
+/**
+ * ナップザック問題を価値軸DPで解く
+ * @param N 品物数
+ * @param W ナップサックの容量
+ * @param items 品物の配列
+ * @returns 価値の合計としてあり得る最大の値
+ */
+function solveKnapsack(N: number, W: number, items: Item[]): number {
+  const maxValue = items.reduce((sum, item) => sum + item.v, 0);
+  const dp: number[] = Array(maxValue + 1).fill(Infinity);
+  dp[0] = 0;
+
+  for (const { w, v } of items) {
+    for (let val = maxValue; val >= v; val--) {
+      if (dp[val - v] + w <= W) {
+        dp[val] = Math.min(dp[val], dp[val - v] + w);
+      }
+    }
+  }
+
+  // dp[v] <= W となる最大の v を返す
+  for (let v = maxValue; v >= 0; v--) {
+    if (dp[v] <= W) return v;
+  }
+  return 0;
+}
+
+/**
+ * メイン関数：標準入力から読み取り、最大価値を出力する
+ * @returns void（標準出力）
+ */
+function main(): void {
+  const input = fs.readFileSync('/dev/stdin', 'utf8');
+  const { N, W, items } = parseInput(input);
+  const result = solveKnapsack(N, W, items);
+  console.log(result);
+}
+
+// エントリーポイント
+main();
+
+// ### ✅ 実行方法（同様）
+
+// ```bash
+// tsc main.ts
+// node main.js < input.txt
+// ```
+
+// ### ✅ 構造化のメリット
+// * **`parseInput`** でテスト可能な構造
+// * **`solveKnapsack`** 単体でアルゴリズム検証可能
+// * `main()` でI/Oを完結させており、**ユニットテストとの分離が容易**
+
+// ✅ 解法のポイント（復習）
+// 制約：W ≤ 1e9 → 重さ軸のDP不可
+// 価値軸でDP：dp[v] = 重さの最小値
+// 配列長：最大で 100 * 1000 = 100,000（安全）
+// 品物ごとに逆順で更新（1個ずつ選ぶため）
+
+// ✅ 実行時パフォーマンスの見積もり
+// 項目	内容
+// 時間計算量	O(N × maxValue) ≈ 1e7
+// メモリ使用量	約 100,000 × 4 byte ≒ 400KB
+// 実行時間制限	10 秒（十分に高速）
+// メモリ制限	1024 MiB（余裕あり）
\ No newline at end of file
diff --git a/Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/README.md b/Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/README.md
new file mode 100644
index 00000000..9ce3c35b
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/Knapsack DP/B19/README.md	
@@ -0,0 +1,209 @@
+以下に、**価値軸DP（Knapsack 2）** の各処理を図を交えて段階的に説明します。
+対象コードは、先ほどの関数分割された TypeScript 実装です。
+
+---
+
+## 🔶 問題概要図
+
+```
+目的：最大の価値 v を得る。ただし合計重量 ≤ W。
+
+入力例：
+  N = 4, W = 7
+  items = [
+    { w: 3, v: 13 },
+    { w: 3, v: 17 },
+    { w: 5, v: 29 },
+    { w: 1, v: 10 }
+  ]
+
+期待出力: 40 （例: 品物1,2,4）
+```
+
+---
+
+## 🔷 `parseInput` の処理図
+
+### 入力文字列:
+
+```
+4 7
+3 13
+3 17
+5 29
+1 10
+```
+
+### 処理内容（分解）:
+
+```ts
+const lines = input.trim().split('\n');  // 行分割
+const [N, W] = lines[0].split(' ').map(Number);  // "4 7" → N=4, W=7
+const items = lines.slice(1).map(...);  // 各行を w, v に変換
+```
+
+### 出力:
+
+```ts
+{
+  N: 4,
+  W: 7,
+  items: [
+    { w: 3, v: 13 },
+    { w: 3, v: 17 },
+    { w: 5, v: 29 },
+    { w: 1, v: 10 }
+  ]
+}
+```
+
+---
+
+## 🔷 `solveKnapsack` のDP処理図（重要）
+
+### 初期状態：
+
+```ts
+dp[0] = 0
+dp[1..69] = Infinity  // maxValue = 13+17+29+10 = 69
+```
+
+```
+価値:     0    1    2   ...  69
+dp[v]:    0   ∞    ∞   ...  ∞
+```
+
+---
+
+### Step1: 品物1（w=3, v=13）を追加
+
+* 更新対象: `dp[13] = min(dp[13], dp[0] + 3) = 3`
+
+```
+価値:     0   1    ... 13  14 ... 69
+dp[v]:    0   ∞    ...  3  ∞  ... ∞
+```
+
+---
+
+### Step2: 品物2（w=3, v=17）を追加
+
+* 更新対象:
+
+  * `dp[17] = dp[0] + 3 = 3`
+  * `dp[30] = dp[13] + 3 = 6`（13+17=30）
+
+```
+価値:     0   ... 13   ... 17   ... 30   ... 69
+dp[v]:    0   ...  3   ...  3   ...  6   ... ∞
+```
+
+---
+
+### Step3: 品物3（w=5, v=29）
+
+* 更新対象:
+
+  * `dp[29] = dp[0] + 5 = 5`
+  * `dp[42] = dp[13] + 5 = 8`
+  * `dp[46] = dp[17] + 5 = 8`
+  * `dp[59] = dp[30] + 5 = 11`
+
+```
+dp[29] = 5
+dp[42] = 8
+dp[46] = 8
+dp[59] = 11
+```
+
+---
+
+### Step4: 品物4（w=1, v=10）
+
+* 更新対象例:
+
+  * `dp[10] = dp[0] + 1 = 1`
+  * `dp[23] = dp[13] + 1 = 4`
+  * `dp[27] = dp[17] + 1 = 4`
+  * `dp[39] = dp[29] + 1 = 6`
+  * `dp[40] = dp[30] + 1 = 7` ✅
+
+```
+dp[10] = 1
+dp[23] = 4
+dp[27] = 4
+dp[39] = 6
+dp[40] = 7 ✅  ← W=7以下で最大価値
+```
+
+---
+
+### 最終 dp 状態（重要な部分のみ抜粋）
+
+```
+dp[v] で v ∈ [0, 69]
+         ↓
+v = 40 → dp[40] = 7  ✅ → これが答え！
+```
+
+---
+
+## 🔷 `main` の処理図
+
+```ts
+// 入力を読み取り
+const input = fs.readFileSync('/dev/stdin', 'utf8');
+
+// データ変換
+const { N, W, items } = parseInput(input);
+
+// 最適解計算
+const result = solveKnapsack(N, W, items);
+
+// 出力
+console.log(result);  // → 40
+```
+
+---
+
+## ✅ 総まとめ図（全体フロー）
+
+```text
+┌────────────┐
+│  標準入力   │
+└────┬───────┘
+     ↓
+┌────────────┐
+│ parseInput │
+│ 戻り値: { N, W, items } │
+└────┬───────┘
+     ↓
+┌──────────────┐
+│ solveKnapsack│
+│ 戻り値: 最大価値 number │
+└────┬────────┘
+     ↓
+┌────────────┐
+│ console.log │
+│ 出力: 最大価値           │
+└────────────┘
+```
+
+---
+
+## ✅ まとめ
+
+| 処理              | 図的説明                  |
+| --------------- | --------------------- |
+| `parseInput`    | 入力 → 数値配列 + オブジェクト化   |
+| `solveKnapsack` | DPテーブルに価値軸で重量記録。逆順更新。 |
+| `main`          | 上記関数を呼び出して結果出力        |
+
+---
+| [提出日時](https://atcoder.jp/contests/tessoku-book/submissions/me?desc=true&orderBy=created) | 問題 | ユーザ | 言語 | [得点](https://atcoder.jp/contests/tessoku-book/submissions/me?desc=true&orderBy=score) | [コード長](https://atcoder.jp/contests/tessoku-book/submissions/me?orderBy=source_length) | 結果 | [実行時間](https://atcoder.jp/contests/tessoku-book/submissions/me?orderBy=time_consumption) | [メモリ](https://atcoder.jp/contests/tessoku-book/submissions/me?orderBy=memory_consumption) |  |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
+| 2025-07-13 12:08:39 | [B19 - Knapsack 2](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_cr) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [Go (go 1.20.6)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5002) | 1000 | 1657 Byte |  | 7 ms | 2368 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67572833) |
+| 2025-07-13 12:06:00 | [B19 - Knapsack 2](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_cr) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [PHP (php 8.2.8)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5016) | 1000 | 1798 Byte |  | 99 ms | 22964 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67572789) |
+| 2025-07-13 12:00:49 | [B19 - Knapsack 2](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_cr) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [Python (CPython 3.11.4)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5055) | 1000 | 1736 Byte |  | 626 ms | 12316 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67572692) |
+| 2025-07-13 11:40:16 | [B19 - Knapsack 2](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_cr) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [TypeScript 5.1 (Node.js 18.16.1)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5058) | 1000 | 1741 Byte |  | 62 ms | 49236 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67572322) |
+| 2025-07-13 11:33:56 | [B19 - Knapsack 2](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_cr) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [JavaScript (Node.js 18.16.1)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5009) | 1000 | 1391 Byte |  | 61 ms | 50300 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67572216) |
\ No newline at end of file

From de1f1ed7ae9885c99f0ade4956ad9b590e76d186 Mon Sep 17 00:00:00 2001
From: myoshizumi <myoshizumi@alumni.berklee.edu>
Date: Sun, 13 Jul 2025 20:03:04 +0900
Subject: [PATCH 2/2] leetcode 14. Longest Common Prefix

---
 .../other/partial sum problem/README.md       | 162 +++++++++++++
 .../partial-sum-problem.js                    | 127 ++++++++++
 .../LongestCommonPrefix.py                    |  99 ++++++++
 .../LongestCommonPrefix.ts                    |  92 ++++++++
 .../14. Longest Common Prefix/README.md       | 217 ++++++++++++++++++
 5 files changed, 697 insertions(+)
 create mode 100644 Algorithm/DynamicProgramming/other/partial sum problem/README.md
 create mode 100644 Algorithm/DynamicProgramming/other/partial sum problem/partial-sum-problem.js
 create mode 100644 Algorithm/Other/leetcode/14. Longest Common Prefix/LongestCommonPrefix.py
 create mode 100644 Algorithm/Other/leetcode/14. Longest Common Prefix/LongestCommonPrefix.ts
 create mode 100644 Algorithm/Other/leetcode/14. Longest Common Prefix/README.md

diff --git a/Algorithm/DynamicProgramming/other/partial sum problem/README.md b/Algorithm/DynamicProgramming/other/partial sum problem/README.md
new file mode 100644
index 00000000..40b15896
--- /dev/null
+++ b/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択を網羅的に考える。
+
+---
diff --git a/Algorithm/DynamicProgramming/other/partial sum problem/partial-sum-problem.js b/Algorithm/DynamicProgramming/other/partial sum problem/partial-sum-problem.js
new file mode 100644
index 00000000..9370a055
--- /dev/null
+++ b/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";
+}
diff --git a/Algorithm/Other/leetcode/14. Longest Common Prefix/LongestCommonPrefix.py b/Algorithm/Other/leetcode/14. Longest Common Prefix/LongestCommonPrefix.py
new file mode 100644
index 00000000..cf5a0e0f
--- /dev/null
+++ b/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標準形式。
+
+# ---
diff --git a/Algorithm/Other/leetcode/14. Longest Common Prefix/LongestCommonPrefix.ts b/Algorithm/Other/leetcode/14. Longest Common Prefix/LongestCommonPrefix.ts
new file mode 100644
index 00000000..5f39b283
--- /dev/null
+++ b/Algorithm/Other/leetcode/14. Longest Common Prefix/LongestCommonPrefix.ts	
@@ -0,0 +1,92 @@
+// 以下はTypeScriptで実装した**最長共通接頭辞 (Longest Common Prefix)** の関数です。
+
+// ### 特徴
+
+// * `fs` モジュールで**処理時間**と**メモリ消費量**を`log.txt`に出力します。
+// * 処理は関数ベースで実装。
+// * パラメータと戻り値はすべてコメント付き。
+
+// ---
+
+// ```typescript
+import * as fs from 'fs';
+
+/**
+ * 最長共通接頭辞を求める関数
+ * @param strs - string型の配列（最長共通接頭辞を求める対象）
+ * @returns string - 最長共通接頭辞。共通部分がなければ空文字を返す。
+ */
+function longestCommonPrefix(strs: string[]): string {
+    if (strs.length === 0) return "";
+
+    let prefix = strs[0];
+
+    for (let i = 1; i < strs.length; i++) {
+        // prefixが一致しなくなるまで短くしていく
+        while (strs[i].indexOf(prefix) !== 0) {
+            prefix = prefix.substring(0, prefix.length - 1);
+            if (prefix === "") return "";
+        }
+    }
+
+    return prefix;
+}
+
+/**
+ * パフォーマンス計測と結果ログ出力用の関数
+ * @param strs - string型の配列（最長共通接頭辞を求める対象）
+ * @param outputPath - ログファイルの出力先パス
+ */
+function runWithPerformanceLog(strs: string[], outputPath: string): void {
+    const startTime = process.hrtime.bigint(); // 高精度時間計測
+    const startMem = process.memoryUsage().heapUsed;
+
+    const result = longestCommonPrefix(strs);
+
+    const endTime = process.hrtime.bigint();
+    const endMem = process.memoryUsage().heapUsed;
+
+    const timeElapsedMs = Number(endTime - startTime) / 1_000_000; // ミリ秒に変換
+    const memoryUsageKb = (endMem - startMem) / 1024; // KBに変換
+
+    const logData = `
+==== Longest Common Prefix Execution ====
+Input: ${JSON.stringify(strs)}
+Output: ${result}
+Time Elapsed: ${timeElapsedMs.toFixed(3)} ms
+Memory Usage: ${memoryUsageKb.toFixed(3)} KB
+=========================================
+`;
+
+    fs.writeFileSync(outputPath, logData);
+}
+
+// サンプル実行
+const example1 = ["flower", "flow", "flight"];
+const example2 = ["dog", "racecar", "car"];
+
+runWithPerformanceLog(example1, 'log_example1.txt');
+runWithPerformanceLog(example2, 'log_example2.txt');
+// ```
+
+// ---
+
+// ## 実行環境
+
+// * TypeScript 5.1
+// * Node.js 18.16.1
+
+// ## 出力ファイル
+
+// * `log_example1.txt`
+// * `log_example2.txt`
+
+// それぞれに**処理時間**と**メモリ消費量**が記録されます。
+
+// ---
+
+// ## 補足
+
+// * `process.hrtime.bigint()` を使うことでナノ秒精度の時間計測ができます。
+// * `process.memoryUsage().heapUsed` はNode.jsのヒープ領域の消費メモリ（バイト）を返します。
+// * `fs.writeFileSync` を使うことで、非同期制御なしで確実にログが出力されます。
diff --git a/Algorithm/Other/leetcode/14. Longest Common Prefix/README.md b/Algorithm/Other/leetcode/14. Longest Common Prefix/README.md
new file mode 100644
index 00000000..34033bfd
--- /dev/null
+++ b/Algorithm/Other/leetcode/14. Longest Common Prefix/README.md	
@@ -0,0 +1,217 @@
+「**Longest Common Prefix (最長共通接頭辞)**」の処理を
+**図解付きで具体的に解析・説明**します。
+
+## アルゴリズム概要：縦方向スキャン
+
+* 最初の文字列を`prefix`に設定
+* 2番目以降の文字列と`prefix`を比較し、
+  一致しない場合は`prefix`を1文字ずつ短くする
+* すべての文字列と一致するまで繰り返す
+
+---
+
+## 例①：「`flower`」「`flow`」「`flight`」
+
+### 初期設定：
+
+```
+prefix = "flower"
+```
+
+---
+
+### 1回目比較（`flow`と比較）
+
+```
+"flower"
+"flow"
+```
+
+一致チェック：
+
+| f | l | o | w | e | r |
+| - | - | - | - | - | - |
+| f | l | o | w |   |   |
+
+**→ 一致する部分：`flow`**
+
+→ `prefix`を「`flow`」に短縮。
+
+---
+
+### 2回目比較（`flight`と比較）
+
+```
+"flow"
+"flight"
+```
+
+一致チェック：
+
+| f | l | o | w |
+| - | - | - | - |
+| f | l | i | g |
+
+→「o ≠ i」で一致失敗。
+
+`prefix`を1文字短くして再チェック：
+
+#### 短縮ループ：
+
+| f | l | o | w |
+| - | - | - | - |
+| f | l | i | g |
+
+1. `"flow"` → `"flo"`
+2. `"flo"` → `"fl"`
+
+| f | l |
+| - | - |
+| f | l |
+
+→ 一致！
+
+---
+
+### 結果：
+
+```
+"fl"
+```
+
+---
+
+## 図解フロー（例①）
+
+```plaintext
+Input: ["flower", "flow", "flight"]
+
+[Start]
+prefix = "flower"
+
+→ Compare with "flow"
+    "flower"
+    "flow"
+→ common: "flow"
+
+→ Compare with "flight"
+    "flow"
+    "flight"
+→ mismatch at 3rd char → shorten prefix
+    "flo" → "fl"
+
+Final Answer: "fl"
+```
+
+---
+
+## 例②：「`dog`」「`racecar`」「`car`」
+
+### 初期設定：
+
+```
+prefix = "dog"
+```
+
+---
+
+### 1回目比較（`racecar`と比較）
+
+```
+"dog"
+"racecar"
+```
+
+| d | o | g |
+| - | - | - |
+| r | a | c |
+
+→ 一致なし。
+
+`prefix`を短縮：
+
+1. "do"
+2. "d"
+3. ""
+
+**→ 空文字になる → 終了**
+
+---
+
+### 結果：
+
+```
+""
+```
+
+---
+
+## 図解フロー（例②）
+
+```plaintext
+Input: ["dog", "racecar", "car"]
+
+[Start]
+prefix = "dog"
+
+→ Compare with "racecar"
+    "dog"
+    "racecar"
+→ no match → shorten prefix to ""
+→ return ""
+
+Final Answer: ""
+```
+
+---
+
+## メモリと時間について
+
+| 項目       | 内容                               |
+| -------- | -------------------------------- |
+| 時間計測     | `process.hrtime.bigint()`使用      |
+| メモリ消費量計測 | `process.memoryUsage().heapUsed` |
+| 記録       | `fs.writeFileSync()`でログ出力        |
+
+---
+
+## 計算量解析
+
+| 項目    | 内容                 |
+| ----- | ------------------ |
+| 時間計算量 | O(S)（Sはすべての文字数の総和） |
+| 空間計算量 | O(1)（出力以外は定数メモリ）   |
+
+---
+
+## 全体処理フロー図（まとめ）
+
+```plaintext
++----------------------+
+| 初期prefix = strs[0] |
++----------------------+
+           |
+           v
++---------------------------+
+| 残りの文字列と逐次比較    |
+| 一致しない部分があれば    |
+| prefixを短くする          |
++---------------------------+
+           |
+           v
++---------------------------+
+| prefixが空になったら終了  |
++---------------------------+
+           |
+           v
++---------------------------+
+| 最終的なprefixを返す     |
++---------------------------+
+```
+
+---
+
+## 追加対応可能：
+
+* **分割統治法版の実装**
+* **Trie木による実装**