From 0d6f67a0727b0d32fff0c7d409a55635ebf2fb54 Mon Sep 17 00:00:00 2001
From: myoshizumi <myoshizumi@alumni.berklee.edu>
Date: Thu, 10 Jul 2025 12:50:03 +0900
Subject: [PATCH 1/2] atcoder B16 - Frog 1 DP

---
 .../DynamicProgramming/atCoder/B16/B16.go     | 113 ++++++++++++
 .../DynamicProgramming/atCoder/B16/B16.js     |  94 ++++++++++
 .../DynamicProgramming/atCoder/B16/B16.php    | 100 +++++++++++
 .../DynamicProgramming/atCoder/B16/B16.py     |  84 +++++++++
 .../DynamicProgramming/atCoder/B16/B16.ts     |  77 ++++++++
 .../DynamicProgramming/atCoder/B16/README.md  | 164 ++++++++++++++++++
 6 files changed, 632 insertions(+)
 create mode 100644 Algorithm/DynamicProgramming/atCoder/B16/B16.go
 create mode 100644 Algorithm/DynamicProgramming/atCoder/B16/B16.js
 create mode 100644 Algorithm/DynamicProgramming/atCoder/B16/B16.php
 create mode 100644 Algorithm/DynamicProgramming/atCoder/B16/B16.py
 create mode 100644 Algorithm/DynamicProgramming/atCoder/B16/B16.ts
 create mode 100644 Algorithm/DynamicProgramming/atCoder/B16/README.md

diff --git a/Algorithm/DynamicProgramming/atCoder/B16/B16.go b/Algorithm/DynamicProgramming/atCoder/B16/B16.go
new file mode 100644
index 00000000..936f4ed4
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/B16/B16.go
@@ -0,0 +1,113 @@
+// 以下は、**Go 1.20.6** を用いた「カエルの最小ジャンプコスト」問題の解法です。
+// **実行時間とメモリの消費量を最小限に抑える**ため、\*\*動的計画法（DP）+ 空間最適化（O(1) メモリ）\*\*を使用します。
+
+// ## ✅ Go 実装（型明示・最小メモリ・高速）
+
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func main() {
+	reader := bufio.NewReader(os.Stdin)
+
+	// 1行目：N
+	line1, _ := reader.ReadString('\n')
+	N, _ := strconv.Atoi(strings.TrimSpace(line1))
+
+	// 2行目：h[0]～h[N-1]
+	line2, _ := reader.ReadString('\n')
+	hStr := strings.Fields(line2)
+	h := make([]int, N)
+	for i := 0; i < N; i++ {
+		h[i], _ = strconv.Atoi(hStr[i])
+	}
+
+	if N == 2 {
+		fmt.Println(abs(h[1] - h[0]))
+		return
+	}
+
+	var prev2 int = 0                             // dp[i-2]
+	var prev1 int = abs(h[1] - h[0])              // dp[i-1]
+
+	for i := 2; i < N; i++ {
+		cost1 := prev1 + abs(h[i]-h[i-1])
+		cost2 := prev2 + abs(h[i]-h[i-2])
+		curr := min(cost1, cost2)
+		prev2 = prev1
+		prev1 = curr
+	}
+
+	fmt.Println(prev1)
+}
+
+func abs(a int) int {
+	if a < 0 {
+		return -a
+	}
+	return a
+}
+
+// ## ✅ 入出力例
+
+// 入力（標準入力）:
+
+// ```
+// 6
+// 30 10 60 10 60 50
+// ```
+
+// 出力:
+
+// ```
+// 40
+// ```
+
+// ---
+
+// ## ✅ 計算量・メモリ量
+
+// | 指標    | 値               |
+// | ----- | --------------- |
+// | 時間計算量 | `O(N)`          |
+// | 空間計算量 | `O(1)`（定数メモリのみ） |
+// | 入力制約  | `2 ≤ N ≤ 10^5`  |
+
+// ---
+
+// ## ✅ ポイントまとめ
+
+// * **配列 `dp[]` を使わず**に、`prev1`, `prev2` の2つだけで更新する。
+// * `abs()` でジャンプコストを計算。
+// * `min()` 関数で2通りのジャンプを比較。
+
+// ---
+
+// ## ✅ フルDP版（O(N)メモリ）も参考に：
+
+// ```go
+// dp := make([]int, N)
+// dp[0] = 0
+// dp[1] = abs(h[1] - h[0])
+// for i := 2; i < N; i++ {
+// 	dp[i] = min(
+// 		dp[i-1]+abs(h[i]-h[i-1]),
+// 		dp[i-2]+abs(h[i]-h[i-2]),
+// 	)
+// }
+// fmt.Println(dp[N-1])
+// ```
+
diff --git a/Algorithm/DynamicProgramming/atCoder/B16/B16.js b/Algorithm/DynamicProgramming/atCoder/B16/B16.js
new file mode 100644
index 00000000..1780d6bb
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/B16/B16.js
@@ -0,0 +1,94 @@
+// 以下に、指定された条件（Node.js 18.16.1、`fs` モジュール使用、実行時間・メモリ効率重視）に従って、**カエルの最小コストジャンプ問題**をJavaScriptで解いた実装を示します。
+
+// ---
+
+// ## ✅ アルゴリズム概要（動的計画法DP）
+
+// * `dp[i]`: 足場 `i` に到達するための最小コスト。
+// * 遷移式：
+
+//   * `dp[i] = min(dp[i-1] + abs(h[i] - h[i-1]), dp[i-2] + abs(h[i] - h[i-2]))`
+// * 初期値：
+
+//   * `dp[0] = 0`
+//   * `dp[1] = abs(h[1] - h[0])`
+
+// ---
+
+// ## ✅ JavaScript (Node.js) 実装（`fs` 使用）
+
+// ```javascript
+// const fs = require('fs');
+
+// function main(input) {
+//   const lines = input.trim().split('\n');
+//   const N = parseInt(lines[0], 10);
+//   const h = lines[1].split(' ').map(Number);
+
+//   const dp = new Array(N).fill(0);
+//   dp[0] = 0;
+//   dp[1] = Math.abs(h[1] - h[0]);
+
+//   for (let i = 2; i < N; i++) {
+//     dp[i] = Math.min(
+//       dp[i - 1] + Math.abs(h[i] - h[i - 1]),
+//       dp[i - 2] + Math.abs(h[i] - h[i - 2])
+//     );
+//   }
+
+//   console.log(dp[N - 1]);
+// }
+
+// // 標準入力から読み込む
+// main(fs.readFileSync('/dev/stdin', 'utf8'));
+// ```
+
+// ---
+
+// ## ✅ 計算量・メモリ使用量
+
+// * **時間計算量**: `O(N)`（1回ずつループ）
+// * **空間計算量**: `O(N)`（DP配列1本）
+
+//   * さらに最適化すれば `O(1)` でも可能（直近2要素のみ使用）
+
+// ---
+
+// ## ✅ 最適化バージョン（メモリ `O(1)`）
+
+// ```javascript
+const fs = require('fs');
+
+function main(input) {
+  const lines = input.trim().split('\n');
+  const N = parseInt(lines[0], 10);
+  const h = lines[1].split(' ').map(Number);
+
+  let prev2 = 0;  // dp[i-2]
+  let prev1 = Math.abs(h[1] - h[0]);  // dp[i-1]
+
+  for (let i = 2; i < N; i++) {
+    const curr = Math.min(
+      prev1 + Math.abs(h[i] - h[i - 1]),
+      prev2 + Math.abs(h[i] - h[i - 2])
+    );
+    prev2 = prev1;
+    prev1 = curr;
+  }
+
+  console.log(prev1);
+}
+
+main(fs.readFileSync('/dev/stdin', 'utf8'));
+
+// ## ✅ 入出力例テスト（例1）
+
+// ```
+// 入力:
+// 4
+// 10 30 40 20
+
+// 出力:
+// 30
+// ```
+
diff --git a/Algorithm/DynamicProgramming/atCoder/B16/B16.php b/Algorithm/DynamicProgramming/atCoder/B16/B16.php
new file mode 100644
index 00000000..ddb5271a
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/B16/B16.php
@@ -0,0 +1,100 @@
+<!-- 以下は、**PHP 8.2.8** での「カエルの最小ジャンプコスト」問題の実装です。
+**処理時間・メモリの消費量を最小限に抑える**ため、\*\*動的計画法（DP）＋ 空間最適化（O(1)メモリ）\*\*を採用しています。
+
+---
+
+## ✅ PHP 実装（型明示、O(1)メモリ最適化）
+<?php
+
+function main(): void {
+    $input = trim(stream_get_contents(STDIN));
+    $lines = explode("\n", $input);
+    
+    /** @var int $N */
+    $N = (int)$lines[0];
+
+    /** @var array<int> $h */
+    $h = array_map('intval', explode(' ', trim($lines[1])));
+
+    if ($N === 2) {
+        echo abs($h[1] - $h[0]) . PHP_EOL;
+        return;
+    }
+
+    /** @var int $prev2 最小コスト（i-2） */
+    $prev2 = 0;
+
+    /** @var int $prev1 最小コスト（i-1） */
+    $prev1 = abs($h[1] - $h[0]);
+
+    for ($i = 2; $i < $N; ++$i) {
+        /** @var int $cost1 足場 i-1 から来た場合のコスト */
+        $cost1 = $prev1 + abs($h[$i] - $h[$i - 1]);
+
+        /** @var int $cost2 足場 i-2 から来た場合のコスト */
+        $cost2 = $prev2 + abs($h[$i] - $h[$i - 2]);
+
+        /** @var int $curr 現在の足場 i への最小コスト */
+        $curr = min($cost1, $cost2);
+
+        $prev2 = $prev1;
+        $prev1 = $curr;
+    }
+
+    echo $prev1 . PHP_EOL;
+}
+
+main();
+
+// ## ✅ 入出力形式
+
+// 標準入力から以下の形式で与えられます：
+
+// ```
+// N
+// h1 h2 h3 ... hN
+// ```
+
+// ### 例：
+
+// ```
+// 6
+// 30 10 60 10 60 50
+// ```
+
+// 出力：
+
+// ```
+// 40
+// ```
+
+// ---
+
+// ## ✅ 計算量とメモリ効率
+
+// | 指標    | 値              |
+// | ----- | -------------- |
+// | 時間計算量 | O(N)           |
+// | 空間計算量 | O(1)（定数個の変数のみ） |
+// | 入力制約  | 2 ≤ N ≤ 10⁵    |
+
+// ## ✅ 解法のポイント
+
+// * `dp[i]` の代わりに、**直前2ステップ（`prev1`, `prev2`）だけ保持**。
+// * `abs()` でジャンプコストを計算。
+// * \*\*配列未使用（O(N)）\*\*のバージョンも実装可能。
+
+// ## ✅ O(N) メモリバージョン（DP配列使用）
+
+// 参考用に、メモリを多く使うフルDP版も示します：
+
+// ```php
+// $dp = array_fill(0, $N, 0);
+// $dp[1] = abs($h[1] - $h[0]);
+// for ($i = 2; $i < $N; $i++) {
+//     $dp[$i] = min(
+//         $dp[$i - 1] + abs($h[$i] - $h[$i - 1]),
+//         $dp[$i - 2] + abs($h[$i] - $h[$i - 2])
+//     );
+// }
+// echo $dp[$N - 1] . PHP_EOL;
\ No newline at end of file
diff --git a/Algorithm/DynamicProgramming/atCoder/B16/B16.py b/Algorithm/DynamicProgramming/atCoder/B16/B16.py
new file mode 100644
index 00000000..d62365db
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/B16/B16.py
@@ -0,0 +1,84 @@
+# 以下は、**Python (CPython 3.11.4)** を用いた「カエルの最小ジャンプコスト」問題の解法です。
+# **処理時間・メモリ使用量を最適化**するため、**動的計画法（DP）+ メモリ O(1) に削減**した実装を提供します。
+
+# ---
+
+# ## ✅ Python 実装（型付き・高速・省メモリ）
+
+# ```python
+import sys
+
+def main() -> None:
+    input: str = sys.stdin.read()
+    lines: list[str] = input.strip().split('\n')
+    
+    N: int = int(lines[0])
+    h: list[int] = list(map(int, lines[1].split()))
+
+    if N == 2:
+        print(abs(h[1] - h[0]))
+        return
+
+    prev2: int = 0  # dp[0]
+    prev1: int = abs(h[1] - h[0])  # dp[1]
+
+    for i in range(2, N):
+        cost1: int = prev1 + abs(h[i] - h[i - 1])
+        cost2: int = prev2 + abs(h[i] - h[i - 2])
+        curr: int = min(cost1, cost2)
+        prev2, prev1 = prev1, curr
+
+    print(prev1)
+
+if __name__ == "__main__":
+    main()
+
+# ## ✅ 入出力形式
+
+# 標準入力から以下のように与えられます：
+
+# ```
+# N
+# h1 h2 h3 ... hN
+# ```
+
+# ---
+
+# ## ✅ 実行例
+
+# 入力:
+
+# ```
+# 6
+# 30 10 60 10 60 50
+# ```
+
+# 出力:
+
+# ```
+# 40
+# ```
+
+# ---
+
+# ## ✅ 計算量とメモリ使用量
+
+# | 項目    | 内容                             |
+# | ----- | ------------------------------ |
+# | 時間計算量 | `O(N)`（1ループ）                   |
+# | 空間計算量 | `O(1)`（直前2個のみ）                 |
+# | 入力制約  | `2 ≤ N ≤ 10^5`、`1 ≤ hᵢ ≤ 10^4` |
+
+# ---
+
+# ## ✅ 補足：DP配列を使ったフル版（メモリ O(N)）
+
+# 必要であれば以下のようにも書けます：
+
+# ```python
+# dp: list[int] = [0] * N
+# dp[1] = abs(h[1] - h[0])
+# for i in range(2, N):
+#     dp[i] = min(dp[i-1] + abs(h[i] - h[i-1]), dp[i-2] + abs(h[i] - h[i-2]))
+# print(dp[N-1])
+# ```
diff --git a/Algorithm/DynamicProgramming/atCoder/B16/B16.ts b/Algorithm/DynamicProgramming/atCoder/B16/B16.ts
new file mode 100644
index 00000000..e3c75b7d
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/B16/B16.ts
@@ -0,0 +1,77 @@
+// 以下は、TypeScript 5.1 + Node.js 18.16.1 環境で、`fs`を使って**最小ジャンプコスト**を求める実装です。
+// 処理時間・メモリ効率を重視し、\*\*動的計画法 + 空間最適化（O(1)メモリ）\*\*を採用しています。
+
+// ---
+
+// ### ✅ TypeScript 実装（最小メモリ使用版）
+
+// ```ts
+import * as fs from 'fs';
+
+function main(input: string): void {
+  const lines: string[] = input.trim().split('\n');
+  const N: number = parseInt(lines[0]);
+  const h: number[] = lines[1].split(' ').map(Number);
+
+  if (N === 2) {
+    console.log(Math.abs(h[1] - h[0]));
+    return;
+  }
+
+  let prev2: number = 0;  // dp[i-2]
+  let prev1: number = Math.abs(h[1] - h[0]);  // dp[i-1]
+
+  for (let i = 2; i < N; i++) {
+    const cost1: number = prev1 + Math.abs(h[i] - h[i - 1]);
+    const cost2: number = prev2 + Math.abs(h[i] - h[i - 2]);
+    const curr: number = Math.min(cost1, cost2);
+    prev2 = prev1;
+    prev1 = curr;
+  }
+
+  console.log(prev1);
+}
+
+main(fs.readFileSync('/dev/stdin', 'utf8'));
+
+// ### ✅ 入力形式（標準入力）
+
+// ```
+// N
+// h1 h2 h3 ... hN
+// ```
+
+// ---
+
+// ### ✅ 処理量・メモリ量の評価
+
+// | 指標      | 内容                                      |
+// | ------- | --------------------------------------- |
+// | 時間計算量   | O(N)                                    |
+// | 空間計算量   | O(1)（DP配列なし）                            |
+// | 標準入力    | `fs.readFileSync('/dev/stdin', 'utf8')` |
+// | 最大対応サイズ | N ≤ 10⁵                                 |
+
+// ---
+
+// ### ✅ 例：入出力
+
+// #### 入力
+
+// ```
+// 6
+// 30 10 60 10 60 50
+// ```
+
+// #### 出力
+
+// ```
+// 40
+// ```
+
+// ---
+
+// ### 🔎 備考
+
+// * 型安全を重視しつつ、パフォーマンスに優れたコードです。
+// * テスト用途では `input.txt` を `fs.readFileSync('input.txt', 'utf8')` などに変更してください。
diff --git a/Algorithm/DynamicProgramming/atCoder/B16/README.md b/Algorithm/DynamicProgramming/atCoder/B16/README.md
new file mode 100644
index 00000000..5d689c4e
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/B16/README.md
@@ -0,0 +1,164 @@
+
+---
+
+## 🔰 問題概要（再掲）
+
+* 高さが `h[0] ~ h[N-1]` の足場がある。
+* カエルは足場 `1`（インデックス `0`）からスタート。
+* 一度に `+1` か `+2` のジャンプができ、ジャンプのコストは `|hi - hj|`。
+* 足場 `N` に到達する最小コストを求める。
+
+---
+
+## 🧠 アルゴリズム概要：動的計画法（DP）
+
+* 定義：`dp[i]` = 足場 `i`（インデックス `i`）まで来る最小コスト
+* 遷移：
+
+  ```
+  dp[i] = min(
+    dp[i-1] + |h[i] - h[i-1]|,
+    dp[i-2] + |h[i] - h[i-2]|
+  )
+  ```
+* 最終出力：`dp[N-1]`
+
+---
+
+## 📘 例題
+
+```
+N = 6
+h = [30, 10, 60, 10, 60, 50]
+```
+
+---
+
+## 🔁 処理の流れと図解
+
+### 🔹 ステップ 1: 初期化
+
+```ts
+let prev2 = 0;  // dp[0] = 0
+let prev1 = Math.abs(h[1] - h[0]); // dp[1] = |10 - 30| = 20
+```
+
+```
+足場:     1    2    3    4    5    6
+Index:    0    1    2    3    4    5
+高さh:   30   10   60   10   60   50
+          ▲    ▲
+        dp[0]=0
+        dp[1]=|10-30|=20
+```
+
+---
+
+### 🔹 ステップ 2: i = 2
+
+```ts
+cost1 = prev1 + |h[2] - h[1]| = 20 + |60 - 10| = 70
+cost2 = prev2 + |h[2] - h[0]| = 0 + |60 - 30| = 30
+dp[2] = min(70, 30) = 30
+```
+
+```
+足場:     1    2    3
+Index:    0    1    2
+高さh:   30   10   60
+dp:       0   20   30
+                      ▲
+        ←―― dp[0]→  dp[2]
+```
+
+---
+
+### 🔹 ステップ 3: i = 3
+
+```ts
+cost1 = dp[2] + |10 - 60| = 30 + 50 = 80
+cost2 = dp[1] + |10 - 10| = 20 + 0 = 20
+dp[3] = min(80, 20) = 20
+```
+
+```
+足場:     1    2    3    4
+Index:    0    1    2    3
+高さh:   30   10   60   10
+dp:       0   20   30   20
+                           ▲
+              ←―― dp[1]→  dp[3]
+```
+
+---
+
+### 🔹 ステップ 4: i = 4
+
+```ts
+cost1 = dp[3] + |60 - 10| = 20 + 50 = 70
+cost2 = dp[2] + |60 - 60| = 30 + 0 = 30
+dp[4] = min(70, 30) = 30
+```
+
+```
+足場:     1    2    3    4    5
+Index:    0    1    2    3    4
+高さh:   30   10   60   10   60
+dp:       0   20   30   20   30
+                                 ▲
+                    ←―― dp[2]→  dp[4]
+```
+
+---
+
+### 🔹 ステップ 5: i = 5
+
+```ts
+cost1 = dp[4] + |50 - 60| = 30 + 10 = 40
+cost2 = dp[3] + |50 - 10| = 20 + 40 = 60
+dp[5] = min(40, 60) = 40
+```
+
+```
+足場:     1    2    3    4    5    6
+Index:    0    1    2    3    4    5
+高さh:   30   10   60   10   60   50
+dp:       0   20   30   20   30   40
+                                       ▲
+                          ←―― dp[4]→  dp[5]
+```
+
+---
+
+## ✅ 結果
+
+```ts
+console.log(prev1); // 最終的に dp[5] = 40
+```
+
+---
+
+## ✅ 最小経路の例（最小コスト経路）
+
+```
+足場1 → 足場3 → 足場5 → 足場6
+ 30     60       60       50
+
+|30-60| + |60-60| + |60-50| = 30 + 0 + 10 = 40 ✅
+```
+
+---
+
+## 🔚 結論
+
+* 各足場で、「1歩ジャンプ」と「2歩ジャンプ」の両方を考え、最小コストで更新。
+* 最後に到達した `dp[N-1]` が答え。
+
+---
+| [提出日時](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-10 12:27:12 | [B16 - Frog 1](https://atcoder.jp/contests/tessoku-book/tasks/dp_a) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [Go (go 1.20.6)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5002) | 100 | 946 Byte |  | 4 ms | 4952 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67462298) |
+| 2025-07-10 12:22:28 | [B16 - Frog 1](https://atcoder.jp/contests/tessoku-book/tasks/dp_a) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [PHP (php 8.2.8)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5016) | 100 | 1030 Byte |  | 32 ms | 28356 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67462225) |
+| 2025-07-10 12:18:51 | [B16 - Frog 1](https://atcoder.jp/contests/tessoku-book/tasks/dp_a) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [Python (CPython 3.11.4)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5055) | 100 | 617 Byte |  | 51 ms | 21064 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67462180) |
+| 2025-07-10 11:46:04 | [B16 - Frog 1](https://atcoder.jp/contests/tessoku-book/tasks/dp_a) | [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) | 100 | 723 Byte |  | 57 ms | 52860 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67461638) |
+| 2025-07-10 11:41:15 | [B16 - Frog 1](https://atcoder.jp/contests/tessoku-book/tasks/dp_a) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [JavaScript (Node.js 18.16.1)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5009) | 100 | 535 Byte |  | 81 ms | 52832 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67461530) |
\ No newline at end of file

From a4bec559191c6185bf113d046f18cfb6b9ad5bdf Mon Sep 17 00:00:00 2001
From: myoshizumi <myoshizumi@alumni.berklee.edu>
Date: Thu, 10 Jul 2025 13:58:14 +0900
Subject: [PATCH 2/2] leetcode 11. Container With Most Water two pointers

---
 .../ContainerWithMostWater.py                 |  88 +++++++++
 .../ContainerWithMostWater.ts                 |  57 ++++++
 .../11. Container With Most Water/README.md   | 168 ++++++++++++++++++
 3 files changed, 313 insertions(+)
 create mode 100644 Algorithm/TwoPointers/leetcode/11. Container With Most Water/ContainerWithMostWater.py
 create mode 100644 Algorithm/TwoPointers/leetcode/11. Container With Most Water/ContainerWithMostWater.ts
 create mode 100644 Algorithm/TwoPointers/leetcode/11. Container With Most Water/README.md

diff --git a/Algorithm/TwoPointers/leetcode/11. Container With Most Water/ContainerWithMostWater.py b/Algorithm/TwoPointers/leetcode/11. Container With Most Water/ContainerWithMostWater.py
new file mode 100644
index 00000000..01d624e2
--- /dev/null
+++ b/Algorithm/TwoPointers/leetcode/11. Container With Most Water/ContainerWithMostWater.py	
@@ -0,0 +1,88 @@
+# LeetCode では、**クラスベースの構造（`class Solution:`）が要求される仕様**です。
+# あなたのエラー：
+
+# ```
+# NameError: name 'Solution' is not defined
+# ```
+
+# は、LeetCode のドライバコードが `Solution().maxArea(...)` を呼び出そうとしているため、`Solution` クラスがないと怒られているという状況です。
+
+# ---
+
+# ## ✅ LeetCode 用に修正した Python 解答
+
+# ```python
+from typing import List
+
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        left: int = 0
+        right: int = len(height) - 1
+        max_area: int = 0
+
+        while left < right:
+            h: int = min(height[left], height[right])
+            w: int = right - left
+            area: int = h * w
+            max_area = max(max_area, area)
+
+            if height[left] < height[right]:
+                left += 1
+            else:
+                right -= 1
+
+        return max_area
+# ```
+
+# ---
+
+# ## ✅ 使い方（LeetCodeでは不要だがローカルテスト用）
+
+# ```python
+# # LeetCodeでは以下は必要ありません。自動で呼ばれます。
+# if __name__ == "__main__":
+#     s = Solution()
+#     print(s.maxArea([1,8,6,2,5,4,8,3,7]))  # 出力: 49
+# ```
+
+# ---
+
+# ## 🧠 メモ
+
+# | 特徴         | 内容                   |
+# | ---------- | -------------------- |
+# | 型ヒント       | `List[int] -> int`   |
+# | 時間計算量      | O(n)                 |
+# | 空間計算量      | O(1)（ポインタと変数のみ）      |
+# | LeetCode対応 | `class Solution` が必須 |
+
+# ---
+
+# これで `Solution` エラーは解消され、LeetCode に貼り付けて提出すれば問題なく動作します。
+
+# ---
+
+# ## 🧠 時間・空間計算量
+
+# | 指標        | 値      | 説明              |
+# | --------- | ------ | --------------- |
+# | **時間計算量** | `O(n)` | 配列を一度走査するだけ     |
+# | **空間計算量** | `O(1)` | 追加の配列や辞書などは使わない |
+
+# ---
+
+# ## 📈 LeetCode 上の性能（目安）
+
+# （2025年現在のLeetCode Python環境での参考値）
+
+# * **実行時間**: 約 **500–800ms**（入力サイズによる）
+# * **メモリ使用量**: 約 **27–30MB**
+# * CPython 3.11.4 環境でもこのアルゴリズムは**線形時間で高速に処理可能**
+
+# ---
+
+# ## 🔍 補足: なぜ Two Pointers が効率的か？
+
+# * すべての組み合わせを調べると **O(n²)** になって非効率。
+# * 一方で、両端から内側に向かって探索することで、**必要な組み合わせだけを調べられる**。
+# * 常に「**幅が広い状態で高さの低い方を捨てる**」ことで面積を最大化できる戦略です。
diff --git a/Algorithm/TwoPointers/leetcode/11. Container With Most Water/ContainerWithMostWater.ts b/Algorithm/TwoPointers/leetcode/11. Container With Most Water/ContainerWithMostWater.ts
new file mode 100644
index 00000000..fbac7b56
--- /dev/null
+++ b/Algorithm/TwoPointers/leetcode/11. Container With Most Water/ContainerWithMostWater.ts	
@@ -0,0 +1,57 @@
+// 以下は、LeetCode 11「Container With Most Water」のTypeScriptでの効率的な解法です。処理時間とメモリ使用量を意識し、**O(n)** 時間・**O(1)** 空間のアルゴリズム（ツーポインター法）を用いています。
+
+// ---
+
+// ### ✅ **TypeScript 解法（Two Pointers アプローチ）**
+
+// ```ts
+function maxArea(height: number[]): number {
+    let maxArea = 0;
+    let left = 0;
+    let right = height.length - 1;
+
+    while (left < right) {
+        const h = Math.min(height[left], height[right]);
+        const w = right - left;
+        const area = h * w;
+        maxArea = Math.max(maxArea, area);
+
+        // 高さの小さい方を内側に移動する
+        if (height[left] < height[right]) {
+            left++;
+        } else {
+            right--;
+        }
+    }
+
+    return maxArea;
+}
+
+// ### 🔍 **アルゴリズムの概要**
+
+// * **初期化**: 両端（`left=0`, `right=n-1`）からスタート
+// * **ループ処理**:
+
+//   * 面積 = `min(height[left], height[right]) * (right - left)`
+//   * 最大面積を更新
+//   * より**低い方のポインタ**を内側に動かす（より高い線が存在する可能性があるため）
+
+// ---
+
+// ### 🧠 **時間・空間計算量**
+
+// | 項目    | 値            |
+// | ----- | ------------ |
+// | 時間計算量 | O(n)         |
+// | 空間計算量 | O(1)（追加領域なし） |
+
+// ---
+
+// ### ✅ **テスト例**
+
+// ```ts
+// console.log(maxArea([1,8,6,2,5,4,8,3,7])); // 49
+// console.log(maxArea([1,1]));             // 1
+// console.log(maxArea([4,3,2,1,4]));       // 16
+// console.log(maxArea([1,2,1]));           // 2
+// ```
diff --git a/Algorithm/TwoPointers/leetcode/11. Container With Most Water/README.md b/Algorithm/TwoPointers/leetcode/11. Container With Most Water/README.md
new file mode 100644
index 00000000..0aa28572
--- /dev/null
+++ b/Algorithm/TwoPointers/leetcode/11. Container With Most Water/README.md	
@@ -0,0 +1,168 @@
+はい、`maxArea` アルゴリズム（ツーポインター法）を **図解付きで各ステップを具体的に説明** します。以下では、例として `height = [1,8,6,2,5,4,8,3,7]` を使って解説します。
+
+---
+
+## 🏗️ 問題の可視化
+
+`height = [1,8,6,2,5,4,8,3,7]`
+この配列は、以下のような棒グラフと見なせます（x軸: index、y軸: height）：
+
+```
+   ↑ y
+ 10|                        
+  9|                        
+  8|    █               █  
+  7|                █     █
+  6|        █              
+  5|            █          
+  4|              █        
+  3|                  █    
+  2|                █      
+  1|█                   █  
+   +-------------------------
+    0 1 2 3 4 5 6 7 8 → x (index)
+```
+
+---
+
+## 🎯 アルゴリズムの目的
+
+* **x軸と2つの縦線**で囲まれる「水を入れる容器」の面積（＝`幅 × 高さ`）を最大化します。
+* 斜めはダメ。両端を固定して面積を計算し、**どちらかのポインタを内側に移動**させます。
+
+---
+
+## 🧮 処理ステップの図解
+
+### ✅ Step 1:
+
+* `left = 0`, `right = 8`（端からスタート）
+* 高さ: `min(height[0], height[8]) = min(1, 7) = 1`
+* 幅: `8 - 0 = 8`
+* 面積: `1 × 8 = 8`
+
+```
+   ↑
+  7|                █     █  ← height[8]=7
+  1|█                   █     ← height[0]=1
+    ↑                   ↑
+  left(0)            right(8)
+```
+
+👉 左が低いので `left++`（内側へ）
+
+---
+
+### ✅ Step 2:
+
+* `left = 1`, `right = 8`
+* 高さ: `min(8, 7) = 7`
+* 幅: `7`
+* 面積: `7 × 7 = 49` ✅ 最大更新！
+
+```
+  8|    █               █
+  7|                █     █
+    ↑               ↑
+  left(1)         right(8)
+```
+
+👉 右が低いので `right--`
+
+---
+
+### ✅ Step 3:
+
+* `left = 1`, `right = 7`
+* 高さ: `min(8, 3) = 3`
+* 幅: `6`
+* 面積: `3 × 6 = 18`
+
+```
+  8|    █               
+  3|                  █  
+    ↑               ↑
+  left(1)         right(7)
+```
+
+👉 右が低いので `right--`
+
+---
+
+### ✅ Step 4:
+
+* `left = 1`, `right = 6`
+* 高さ: `min(8, 8) = 8`
+* 幅: `5`
+* 面積: `8 × 5 = 40`
+
+```
+  8|    █         █    
+    ↑         ↑
+  left(1)   right(6)
+```
+
+👉 左右同じなので `right--`（どちらでもOK）
+
+---
+
+### ✅ Step 5:
+
+* `left = 1`, `right = 5`
+* 高さ: `min(8, 4) = 4`
+* 幅: `4`
+* 面積: `4 × 4 = 16`
+
+👉 `right--`
+
+---
+
+### ✅ Step 6:
+
+* `left = 1`, `right = 4`
+* 高さ: `min(8, 5) = 5`
+* 幅: `3`
+* 面積: `5 × 3 = 15`
+
+👉 `right--`
+
+---
+
+### ✅ Step 7:
+
+* `left = 1`, `right = 3`
+* 高さ: `min(8, 2) = 2`
+* 幅: `2`
+* 面積: `2 × 2 = 4`
+
+👉 `right--`
+
+---
+
+### ✅ Step 8:
+
+* `left = 1`, `right = 2`
+* 高さ: `min(8, 6) = 6`
+* 幅: `1`
+* 面積: `6 × 1 = 6`
+
+👉 `right--` → 終了（`left == right`）
+
+---
+
+## ✅ 結果
+
+最大面積 = **49**
+
+---
+
+## 🧠 ポイントまとめ
+
+| ステップ   | 処理                                                  |
+| ------ | --------------------------------------------------- |
+| 初期化    | `left=0, right=n-1`                                 |
+| 面積計算   | `(right - left) * min(height[left], height[right])` |
+| ポインタ更新 | 小さい方を内側へ動かす（→ 高さの可能性を探す）                            |
+| 終了条件   | `left >= right`                                     |
+
+---