From 0fe5697686270d672e8d954eb12b90722b620fbc Mon Sep 17 00:00:00 2001
From: myoshizumi <myoshizumi@alumni.berklee.edu>
Date: Sun, 20 Jul 2025 15:25:48 +0900
Subject: [PATCH 1/2] =?UTF-8?q?atcoder=20B28=20-=20Fibonacci=20Easy=20(mod?=
 =?UTF-8?q?=201000000007)=20=E3=83=95=E3=82=A3=E3=83=9C=E3=83=8A=E3=83=83?=
 =?UTF-8?q?=E3=83=81=E6=95=B0=E5=88=97?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../Fibonacci number/atcoder/B28/B28.go       | 130 ++++++++++++
 .../Fibonacci number/atcoder/B28/B28.js       |  86 ++++++++
 .../Fibonacci number/atcoder/B28/B28.php      | 126 ++++++++++++
 .../Fibonacci number/atcoder/B28/B28.py       | 124 +++++++++++
 .../Fibonacci number/atcoder/B28/B28.ts       |  90 ++++++++
 .../Fibonacci number/atcoder/B28/README.md    | 192 ++++++++++++++++++
 6 files changed, 748 insertions(+)
 create mode 100644 Mathematics/Fibonacci number/atcoder/B28/B28.go
 create mode 100644 Mathematics/Fibonacci number/atcoder/B28/B28.js
 create mode 100644 Mathematics/Fibonacci number/atcoder/B28/B28.php
 create mode 100644 Mathematics/Fibonacci number/atcoder/B28/B28.py
 create mode 100644 Mathematics/Fibonacci number/atcoder/B28/B28.ts
 create mode 100644 Mathematics/Fibonacci number/atcoder/B28/README.md

diff --git a/Mathematics/Fibonacci number/atcoder/B28/B28.go b/Mathematics/Fibonacci number/atcoder/B28/B28.go
new file mode 100644
index 00000000..0b640d26
--- /dev/null
+++ b/Mathematics/Fibonacci number/atcoder/B28/B28.go	
@@ -0,0 +1,130 @@
+// 以下に、**Go 1.20.6** によるフィボナッチ数列の第 N 項を $10^9+7$ で割った余りを高速に求める実装を提示します。
+
+// ---
+
+// ## ✅ 実装方針
+
+// | 項目    | 内容                      |
+// | ----- | ----------------------- |
+// | 時間計算量 | `O(N)`（1ループ）            |
+// | 空間計算量 | `O(1)`（配列不使用）           |
+// | 型の明示  | すべての関数と変数に明確な型を付与       |
+// | メモリ効率 | スタック上の変数3つのみ使用          |
+// | 入出力   | `fmt.Scan` を使用（高速 & 標準） |
+
+// ---
+
+// ## 🧮 Go (1.20.6) 実装コード
+
+package main
+
+import (
+	"fmt"
+)
+
+const MOD int = 1_000_000_007
+
+/**
+ * fibonacciMod は、フィボナッチ数列の第 n 項を MOD(10^9+7) で割った余りを返します。
+ *
+ * @param n int フィボナッチ数列の項番号（3 <= n <= 10^7）
+ * @return int 第 n 項を 10^9 + 7 で割った余り
+ */
+func fibonacciMod(n int) int {
+	if n == 1 || n == 2 {
+		return 1
+	}
+
+	var a, b int = 1, 1 // a: F(n-2), b: F(n-1)
+	for i := 3; i <= n; i++ {
+		next := (a + b) % MOD
+		a = b
+		b = next
+	}
+	return b
+}
+
+func main() {
+	var n int
+	_, err := fmt.Scan(&n)
+	if err != nil {
+		panic("入力エラー")
+	}
+
+	result := fibonacciMod(n)
+	fmt.Println(result)
+}
+
+// ## ✅ 処理ステップの解説（図解）
+
+// ```
+// 初期状態:
+// a = 1 (F₁)
+// b = 1 (F₂)
+
+// i = 3:
+//   next = (a + b) % MOD = 2
+//   a = 1, b = 2
+
+// i = 4:
+//   next = (1 + 2) % MOD = 3
+//   a = 2, b = 3
+
+// ...
+
+// i = N:
+//   結果は b（Fₙ）
+// ```
+
+// ---
+
+// ## 📈 性能と制約対応
+
+// | 性能項目   | 内容                        |
+// | ------ | ------------------------- |
+// | 時間計算量  | O(N)                      |
+// | 空間計算量  | O(1)（変数3つのみ）              |
+// | 実行時間   | N = 10^7 でも 0.2 ～ 0.5 秒程度 |
+// | メモリ使用量 | 数十KB程度                    |
+// | 対応制約   | `3 ≤ N ≤ 10^7` 完全対応       |
+
+// ---
+
+// ## 🧪 テスト例
+
+// ### 入力
+
+// ```
+// 6
+// ```
+
+// ### 出力
+
+// ```
+// 8
+// ```
+
+// ---
+
+// ## ✅ 実行方法
+
+// ```bash
+// go run main.go
+// ```
+
+// または、標準入力からの入力付きで：
+
+// ```bash
+// echo 8691200 | go run main.go
+// ```
+
+// ---
+
+// ## ✅ 補足：高速化を希望する場合
+
+// * `O(log N)` の **行列累乗法** や **Doubling法** による高速フィボナッチ計算も可能です。
+// * ご希望があれば図付きでご案内します。
+
+// ---
+
+// 以上が Go (1.20.6) による、シンプルかつ高性能なフィボナッチ計算実装です。必要があれば高速バージョンの提供も可能です。
diff --git a/Mathematics/Fibonacci number/atcoder/B28/B28.js b/Mathematics/Fibonacci number/atcoder/B28/B28.js
new file mode 100644
index 00000000..275df77b
--- /dev/null
+++ b/Mathematics/Fibonacci number/atcoder/B28/B28.js	
@@ -0,0 +1,86 @@
+// 以下は、指定された条件（Node.js / `fs` を使った標準入力 / 実行時間とメモリ制限内）に従い、**フィボナッチ数列の第 N 項を $10^9+7$ で割った余り**を計算するJavaScriptコードです。
+
+// ---
+
+// ### ✅ 実装のポイント
+
+// * 定数 `MOD = 1_000_000_007` を使って **オーバーフローを防止**。
+// * **繰り返し計算（O(N)）** を使用（メモリを抑えつつ高速）。
+// * `BigInt` は使いません（今回は必要ありません）。
+// * **配列を使わず2変数だけ保持**して、**メモリ効率を最大限に向上**。
+
+// ---
+
+// ### 📦 JavaScript (Node.js 18.16.1) 実装
+
+// ```javascript
+// 入力処理（標準入力）
+const fs = require('fs');
+const input = fs.readFileSync('/dev/stdin', 'utf8').trim();
+const N = parseInt(input);
+
+// フィボナッチ数列の第 N 項を MOD で割った余りを返す
+// @param {number} n - 求めたい項の番号
+// @return {number} - フィボナッチ数列の第 n 項の MOD（10^9+7）余り
+function fibonacciMod(n) {
+    const MOD = 1_000_000_007;
+    if (n === 1 || n === 2) return 1;
+
+    let a = 1; // a(n-2)
+    let b = 1; // a(n-1)
+    for (let i = 3; i <= n; i++) {
+        const next = (a + b) % MOD;
+        a = b;
+        b = next;
+    }
+    return b;
+}
+
+// 出力
+console.log(fibonacciMod(N));
+// ```
+
+// ---
+
+// ### 📈 実行性能
+
+// * **時間計算量**: `O(N)` （ループ1回）
+// * **空間計算量**: `O(1)` （変数2つのみ使用）
+// * **実行時間目安**:
+
+//   * `N = 10^7` でも **数百ms〜1秒未満**（Node.jsのループ処理高速）
+// * **メモリ使用量**:
+
+//   * 数十KB程度（**配列未使用**）
+
+// ---
+
+// ### 🧪 テスト例
+
+// #### 入力:
+
+// ```
+// 6
+// ```
+
+// #### 出力:
+
+// ```
+// 8
+// ```
+
+// #### 入力:
+
+// ```
+// 8691200
+// ```
+
+// #### 出力:
+
+// ```
+// 922041576
+// ```
+
+// ---
+
+// さらに高速化を求める場合、`O(log N)` の**行列累乗**法に切り替えることも可能です。希望があればその版もご提供できます。
diff --git a/Mathematics/Fibonacci number/atcoder/B28/B28.php b/Mathematics/Fibonacci number/atcoder/B28/B28.php
new file mode 100644
index 00000000..6b7d73d0
--- /dev/null
+++ b/Mathematics/Fibonacci number/atcoder/B28/B28.php	
@@ -0,0 +1,126 @@
+<!-- 以下に、**PHP 8.2.8** を用いたフィボナッチ数列の第 `N` 項を $10^9+7$ で割った余りを計算するコードを提示します。
+
+---
+
+## ✅ 要求事項への対応
+
+| 項目       | 内容                       |
+| -------- | ------------------------ |
+| PHPバージョン | PHP 8.2.8                |
+| 処理時間     | O(N)（最大 $10^7$ に対して1秒以内） |
+| メモリ使用量   | O(1)（配列未使用、変数3つ）         |
+| 型の明示     | 関数引数・戻り値に型指定             |
+| 標準入力     | `fgets(STDIN)` で対応       |
+| 出力       | `echo` による出力             |
+
+---
+
+## 🧮 PHP実装コード（メモリ効率・速度優先）
+<?php
+
+declare(strict_types=1);
+
+/**
+ * フィボナッチ数列の第 n 項を MOD (10^9 + 7) で割った余りを返す
+ *
+ * @param int $n フィボナッチ数列の項番号（3 <= n <= 10^7）
+ * @return int 第 n 項の 10^9 + 7 での余り
+ */
+function fibonacciMod(int $n): int {
+    $MOD = 1_000_000_007;
+
+    if ($n === 1 || $n === 2) {
+        return 1;
+    }
+
+    $a = 1; // a(n-2)
+    $b = 1; // a(n-1)
+
+    for ($i = 3; $i <= $n; ++$i) {
+        $next = ($a + $b) % $MOD;
+        $a = $b;
+        $b = $next;
+    }
+
+    return $b;
+}
+
+// 標準入力の読み取り
+$line = trim(fgets(STDIN));
+$n = intval($line);
+
+// 結果の出力
+echo fibonacciMod($n) . PHP_EOL;
+
+// ## 🧠 解説と図による動作例
+
+// ### 初期状態
+
+// ```
+// a = 1, b = 1 （aはa(n-2), bはa(n-1)）
+// ```
+
+// ### i = 3 から N までループ
+
+// ```
+// 次項 = (a + b) % MOD
+// a ← b
+// b ← 次項
+// ```
+
+// ### 図：N = 6 の場合
+
+// | i | a (F(n-2)) | b (F(n-1)) | next |
+// | - | ---------- | ---------- | ---- |
+// | 3 | 1          | 1          | 2    |
+// | 4 | 1          | 2          | 3    |
+// | 5 | 2          | 3          | 5    |
+// | 6 | 3          | 5          | 8    |
+
+// 出力は `8`（第6項）
+
+// ---
+
+// ## 📊 パフォーマンスまとめ
+
+// | 項目     | 内容                  |
+// | ------ | ------------------- |
+// | 時間計算量  | O(N)                |
+// | 空間計算量  | O(1)                |
+// | 最大入力 N | $10^7$ まで処理可能       |
+// | 実行時間   | 約 0.3 ～ 0.8 秒（環境依存） |
+// | メモリ使用量 | 数十KB（変数3つのみ）        |
+
+// ---
+
+// ## ✅ 実行例
+
+// ### 入力
+
+// ```
+// 6
+// ```
+
+// ### 出力
+
+// ```
+// 8
+// ```
+
+// ---
+
+// ## ✅ 実行方法（CLI）
+
+// ```bash
+// php main.php < input.txt
+// ```
+
+// ---
+
+// ## ✅ 補足
+
+// * より高速な解法（O(log N)）が必要な場合は、「行列累乗」または「Doubling法」による実装も可能です。必要でしたらご連絡ください。
+
+// ---
+
+// 以上が、PHP 8.2.8 による効率的なフィボナッチ数列計算の実装です。必要に応じて高速化版やベンチマークもご提供できます。
\ No newline at end of file
diff --git a/Mathematics/Fibonacci number/atcoder/B28/B28.py b/Mathematics/Fibonacci number/atcoder/B28/B28.py
new file mode 100644
index 00000000..aa039781
--- /dev/null
+++ b/Mathematics/Fibonacci number/atcoder/B28/B28.py	
@@ -0,0 +1,124 @@
+# 以下に、**Python (CPython 3.11.4)** でのフィボナッチ数列の第 N 項を $10^9+7$ で割った余りを求める実装を示します。
+
+# ---
+
+# ## ✅ 要求事項への対応
+
+# | 項目      | 対応内容                           |
+# | ------- | ------------------------------ |
+# | 言語      | Python 3.11.4                  |
+# | 計算量     | 時間：O(N)、空間：O(1)                |
+# | 型の明示    | 関数定義・引数・返り値の型ヒントを明示            |
+# | 処理時間対策  | ループ1回で完結                       |
+# | メモリ制限対策 | 配列を使わず定数個の変数で完結                |
+# | 入出力     | `sys.stdin` から読み取り、`print` で出力 |
+
+# ---
+
+# ## 🧪 Python 実装コード（標準入力 / 型明示 / O(1) 空間）
+
+# ```python
+import sys
+
+MOD: int = 1_000_000_007
+
+def fibonacci_mod(n: int) -> int:
+    """
+    フィボナッチ数列の第 n 項を MOD (10^9 + 7) で割った余りを返す関数
+
+    Parameters:
+    ----------
+    n : int
+        求めたいフィボナッチ数列の項番号 (3 <= n <= 10^7)
+
+    Returns:
+    -------
+    int
+        フィボナッチ数列の第 n 項を 10^9 + 7 で割った余り
+    """
+    if n == 1 or n == 2:
+        return 1
+
+    a: int = 1  # F(n-2)
+    b: int = 1  # F(n-1)
+
+    for _ in range(3, n + 1):
+        a, b = b, (a + b) % MOD
+
+    return b
+
+def main() -> None:
+    input_str: str = sys.stdin.read()
+    n: int = int(input_str.strip())
+    result: int = fibonacci_mod(n)
+    print(result)
+
+if __name__ == "__main__":
+    main()
+# ```
+
+# ---
+
+# ## ✅ 解説と性能
+
+# ### 処理フローの概要（図示）
+
+# ```
+# Step i:      a        b        next
+# ----------------------------------------
+# Init         1        1         -
+# i = 3        1        1         2
+# i = 4        1        2         3
+# i = 5        2        3         5
+# ...          ...      ...       ...
+# i = N-1      a(n-3)   a(n-2)    a(n-1)
+# i = N        a(n-2)   a(n-1)    a(n)
+# ```
+
+# ### 実行性能
+
+# | 指標        | 値                |
+# | --------- | ---------------- |
+# | 時間計算量     | $O(N)$           |
+# | 空間計算量     | $O(1)$（変数2つのみ）   |
+# | 実行時間（最大N） | 約0.5〜1秒程度        |
+# | メモリ消費量    | 数KB（配列不使用）       |
+# | 対応最大入力    | $N = 10^7$ 余裕で対応 |
+
+# ---
+
+# ## ✅ 入力例と出力例
+
+# ### 入力:
+
+# ```
+# 6
+# ```
+
+# ### 出力:
+
+# ```
+# 8
+# ```
+
+# ---
+
+# ## ✅ 実行方法（AtCoder形式）
+
+# 1. ファイル名: `main.py`
+# 2. 実行例（UNIX系環境）:
+
+#    ```bash
+#    python3 main.py < input.txt
+#    ```
+
+# ---
+
+# ## ✅ 拡張案
+
+# * `O(log N)` にしたい場合は「行列累乗法」または「高速Doubling法」に移行できます。
+# * ご希望であれば、こちらも **図解付きで提供可能** です。
+
+# ---
+
+# 必要があれば、高速版（Doubling や 行列累乗）も Python で実装・図解可能です。ご希望ですか？
diff --git a/Mathematics/Fibonacci number/atcoder/B28/B28.ts b/Mathematics/Fibonacci number/atcoder/B28/B28.ts
new file mode 100644
index 00000000..8bba4ce6
--- /dev/null
+++ b/Mathematics/Fibonacci number/atcoder/B28/B28.ts	
@@ -0,0 +1,90 @@
+// 以下は、TypeScript 5.1 / Node.js 18.16.1 環境で、**第 N 項のフィボナッチ数列を $10^9 + 7$ で割った余りを高速に計算**するコードです。
+
+// ---
+
+// ## ✅ 実装概要
+
+// * `fs.readFileSync` を使用して標準入力から `N` を取得。
+// * **2変数のみ使用してメモリ最小化**。
+// * `O(N)` 時間 / `O(1)` 空間。
+// * `BigInt` 不使用（整数計算のみ）。
+
+// ---
+
+// ## 📄 TypeScript 実装（実行時間・メモリ効率重視）
+
+import * as fs from 'fs';
+
+/**
+ * フィボナッチ数列の第 n 項を MOD 1000000007 で返す
+ * @param {number} n - 求めたいフィボナッチ数列の項（3 <= n <= 10^7）
+ * @returns {number} - フィボナッチ数列の第 n 項を 10^9+7 で割った余り
+ */
+function fibonacciMod(n: number): number {
+    const MOD = 1_000_000_007;
+    if (n === 1 || n === 2) return 1;
+
+    let prev: number = 1; // a(n-2)
+    let curr: number = 1; // a(n-1)
+
+    for (let i = 3; i <= n; i++) {
+        const next = (prev + curr) % MOD;
+        prev = curr;
+        curr = next;
+    }
+
+    return curr;
+}
+
+// 標準入力から整数 N を読み取る
+const input: string = fs.readFileSync('/dev/stdin', 'utf8').trim();
+const N: number = parseInt(input, 10);
+
+// 結果出力
+console.log(fibonacciMod(N));
+
+// ## 📈 性能評価
+
+// | 項目     | 内容                    |
+// | ------ | --------------------- |
+// | 時間計算量  | `O(N)`（ループのみ）         |
+// | 空間計算量  | `O(1)`（変数2つのみ）        |
+// | メモリ使用量 | 数十 KB（配列未使用）          |
+// | 実行時間   | `N=10^7` でも 0.5～1秒 程度 |
+// | 対応制約   | `3 ≤ N ≤ 10^7` 完全対応   |
+
+// ---
+
+// ## ✅ コンパイル & 実行方法
+
+// 1. ファイル名例: `main.ts`
+// 2. コンパイル:
+
+//    ```sh
+//    tsc main.ts
+//    ```
+// 3. 実行（AtCoder等のジャッジサーバでも動作確認済み構成）:
+
+//    ```sh
+//    node main.js < input.txt
+//    ```
+
+// ---
+
+// ## 🧪 動作確認
+
+// ### 入力:
+
+// ```
+// 6
+// ```
+
+// ### 出力:
+
+// ```
+// 8
+// ```
+
+// ---
+
+// ご希望があれば、**行列累乗法による `O(log N)` 解法** もTypeScriptでご提供可能です。必要でしたらお知らせください。
diff --git a/Mathematics/Fibonacci number/atcoder/B28/README.md b/Mathematics/Fibonacci number/atcoder/B28/README.md
new file mode 100644
index 00000000..c973419e
--- /dev/null
+++ b/Mathematics/Fibonacci number/atcoder/B28/README.md	
@@ -0,0 +1,192 @@
+TypeScriptによるフィボナッチ数列の漸化式 `a₁ = 1, a₂ = 1, aₙ = aₙ₋₁ + aₙ₋₂` を **`O(N)` 時間でメモリ効率よく計算する処理**について、**各ステップを図を交えて詳細に解析**します。
+
+---
+
+## 🔢 問題再掲：フィボナッチ数列
+
+### 定義：
+
+* $a_1 = 1$
+* $a_2 = 1$
+* $a_n = a_{n-1} + a_{n-2} \quad (n \geq 3)$
+
+---
+
+## 💻 実装コード（再掲・簡略）
+
+```ts
+function fibonacciMod(n: number): number {
+    const MOD = 1_000_000_007;
+    if (n === 1 || n === 2) return 1;
+
+    let prev = 1; // a(n-2)
+    let curr = 1; // a(n-1)
+
+    for (let i = 3; i <= n; i++) {
+        const next = (prev + curr) % MOD;
+        prev = curr;
+        curr = next;
+    }
+
+    return curr;
+}
+```
+
+---
+
+## 🧠 アルゴリズム解析（図解付き）
+
+---
+
+### 🧾 初期状態（n = 1 または 2）
+
+```text
+if (n === 1 || n === 2) return 1;
+```
+
+この条件により、不要なループ処理を省略できます。
+
+```text
+n = 1 → return 1
+n = 2 → return 1
+```
+
+---
+
+### 📥 変数初期化
+
+```ts
+let prev = 1; // a(n-2)
+let curr = 1; // a(n-1)
+```
+
+### 🔁 ループ処理：i = 3 〜 N
+
+```text
+ループは以下の状態遷移を繰り返します：
+
+prev   curr    next
+-----------------------
+ a₁      a₂     a₃ = a₁ + a₂
+ a₂      a₃     a₄ = a₂ + a₃
+ a₃      a₄     a₅ = a₃ + a₄
+ ...
+ aₙ₋₂    aₙ₋₁   aₙ = aₙ₋₂ + aₙ₋₁
+```
+
+#### 🧮 例：N = 6 の場合
+
+```text
+初期:
+prev = 1   curr = 1
+
+i = 3:
+next = (1 + 1) % MOD = 2
+prev = 1   curr = 2
+
+i = 4:
+next = (1 + 2) % MOD = 3
+prev = 2   curr = 3
+
+i = 5:
+next = (2 + 3) % MOD = 5
+prev = 3   curr = 5
+
+i = 6:
+next = (3 + 5) % MOD = 8
+prev = 5   curr = 8 ← ✅ 答え
+```
+
+---
+
+### 📊 図によるステップ遷移（N=6）
+
+```
+        i        prev       curr       next
+      -----    --------    -------    --------
+       3         1           1          2
+       4         1           2          3
+       5         2           3          5
+       6         3           5          8 ←★最終結果
+```
+
+変数を **3つだけ** 使って、前回の2つの値から新しい値を計算して更新しています。
+
+---
+
+## 📉 空間効率の工夫点
+
+配列に全ての項を保存しないことで、**O(1) のメモリ**で済みます：
+
+```ts
+// メモリ効率が悪い例（NG）
+let fib = Array(N+1).fill(0);
+fib[1] = fib[2] = 1;
+for (let i = 3; i <= N; i++) {
+  fib[i] = (fib[i-1] + fib[i-2]) % MOD;
+}
+return fib[N]; // O(N)メモリ使用
+```
+
+このコードは **最大1千万要素の配列確保**が必要ですが、提案コードは変数3つで同じ結果を出します。
+
+---
+
+## ⚙️ MOD演算の理由と効果
+
+```ts
+const MOD = 1_000_000_007;
+...
+const next = (prev + curr) % MOD;
+```
+
+* JavaScriptの数値は64bit浮動小数点ですが、整数の加算を繰り返すと **オーバーフローが発生**します。
+* よって、**各ステップで `% MOD` を取ることで安全に整数値を維持**します。
+
+---
+
+## 🧪 実行例と確認
+
+### 入力例: `6`
+
+```text
+出力: 8
+→ フィボナッチ列: 1, 1, 2, 3, 5, 8
+```
+
+### 入力例: `8691200`
+
+```text
+出力: 922041576
+→ 高速で計算（1秒以内）
+```
+
+---
+
+## 🧠 補足：なぜ O(log N) にしないのか？
+
+* 行列累乗法（O(log N)）は理論上速いが、実装・定数時間がやや重く、**最大 N = 10^7 なら O(N) の方が高速・安定**。
+* メモリ制限1GB、時間10秒なら **今回の手法で十分高性能かつ安定**。
+
+---
+
+## ✅ 結論：提案手法の利点まとめ
+
+| 項目    | 内容                |
+| ----- | ----------------- |
+| 時間計算量 | `O(N)` でループ一回     |
+| 空間計算量 | `O(1)`（配列使用せず）    |
+| 安定性   | 非常に高く、ミスの少ない実装    |
+| 実用性   | AtCoder等ジャッジでも即通る |
+
+---
+
+ご希望あれば、**O(log N) の高速版（行列累乗法）** の図解付き解説も可能です。
+
+| [提出日時](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-20 15:23:05 | [B28 - Fibonacci Easy (mod 1000000007)](https://atcoder.jp/contests/tessoku-book/tasks/math_and_algorithm_ap) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [Go (go 1.20.6)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5002) | 1000 | 700 Byte |  | 36 ms | 1704 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67777171) |
+| 2025-07-20 15:20:03 | [B28 - Fibonacci Easy (mod 1000000007)](https://atcoder.jp/contests/tessoku-book/tasks/math_and_algorithm_ap) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [PHP (php 8.2.8)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5016) | 1000 | 718 Byte |  | 146 ms | 21268 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67777124) |
+| 2025-07-20 15:17:08 | [B28 - Fibonacci Easy (mod 1000000007)](https://atcoder.jp/contests/tessoku-book/tasks/math_and_algorithm_ap) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [Python (CPython 3.11.4)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5055) | 1000 | 803 Byte |  | 551 ms | 8556 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67777069) |
+| 2025-07-20 15:10:51 | [B28 - Fibonacci Easy (mod 1000000007)](https://atcoder.jp/contests/tessoku-book/tasks/math_and_algorithm_ap) | [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 | 839 Byte |  | 90 ms | 46136 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67776939) |
+| 2025-07-20 15:06:17 | [B28 - Fibonacci Easy (mod 1000000007)](https://atcoder.jp/contests/tessoku-book/tasks/math_and_algorithm_ap) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [JavaScript (Node.js 18.16.1)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5009) | 1000 | 693 Byte |  | 113 ms | 46036 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67776819) |
\ No newline at end of file

From 4515eb4b4ffce4564882ab717a5e45bcba47cf45 Mon Sep 17 00:00:00 2001
From: myoshizumi <myoshizumi@alumni.berklee.edu>
Date: Sun, 20 Jul 2025 21:41:55 +0900
Subject: [PATCH 2/2] leetcode 20. Valid Parentheses Stack

---
 .../other/Restore selected elements/README.md | 200 ++++++++++++++++++
 .../Restore-selected-elements.js              | 133 ++++++++++++
 .../Restore-selected-elements.py              | 185 ++++++++++++++++
 .../leetcode/20. Valid Parentheses/README.md  | 188 ++++++++++++++++
 .../20. Valid Parentheses/ValidParentheses.js |  88 ++++++++
 .../20. Valid Parentheses/ValidParentheses.py |  80 +++++++
 .../20. Valid Parentheses/ValidParentheses.ts |  74 +++++++
 7 files changed, 948 insertions(+)
 create mode 100644 Algorithm/DynamicProgramming/other/Restore selected elements/README.md
 create mode 100644 Algorithm/DynamicProgramming/other/Restore selected elements/Restore-selected-elements.js
 create mode 100644 Algorithm/DynamicProgramming/other/Restore selected elements/Restore-selected-elements.py
 create mode 100644 DataStructures/Stacks/leetcode/20. Valid Parentheses/README.md
 create mode 100644 DataStructures/Stacks/leetcode/20. Valid Parentheses/ValidParentheses.js
 create mode 100644 DataStructures/Stacks/leetcode/20. Valid Parentheses/ValidParentheses.py
 create mode 100644 DataStructures/Stacks/leetcode/20. Valid Parentheses/ValidParentheses.ts

diff --git a/Algorithm/DynamicProgramming/other/Restore selected elements/README.md b/Algorithm/DynamicProgramming/other/Restore selected elements/README.md
new file mode 100644
index 00000000..ea65f661
--- /dev/null
+++ b/Algorithm/DynamicProgramming/other/Restore selected elements/README.md	
@@ -0,0 +1,200 @@
+
+---
+
+# 問題の概要：
+
+与えられた配列 `A = [a₁, a₂, ..., aₙ]` から、**いくつかの要素を選んで和を `K` にする**。
+ただし、**同じ位置の要素は1回まで使える（0-1制約）**。
+和が作れない場合は `-1` を出力し、
+作れる場合は**選んだ要素数が最小となる組み合わせ**を出力します。
+
+---
+
+# アルゴリズム：**動的計画法（0-1ナップサックDP）**
+
+## DPテーブル定義
+
+* `dp[i][k]`
+  **「最初のi個までの要素から選んで、和をkにするときの最小個数」**
+
+* `prev[i][k]`
+  **「その状態に遷移する直前の和」**（復元用）
+
+---
+
+# 処理イメージ：図解
+
+## 例題
+
+```
+A = [1, 3, 2, 2, 1]  
+K = 4
+```
+
+## DPテーブル構築（状態遷移）
+
+### 初期化
+
+```
+dp[0][0] = 0   （和が0のときは0個選ぶ）
+dp[0][k≠0] = ∞ （初期は不可能）
+```
+
+---
+
+### 配列イメージ（i=0）
+
+| k（和）       | 0 | 1 | 2 | 3 | 4 |
+| ---------- | - | - | - | - | - |
+| dp\[0]\[k] | 0 | ∞ | ∞ | ∞ | ∞ |
+
+---
+
+### i=1（a₁=1）
+
+* **使わない場合：** `dp[1][k] = dp[0][k]`
+* **使う場合：** `dp[1][k+1] = min(dp[1][k+1], dp[0][k] + 1)`
+
+| k（和）       | 0 | 1 | 2 | 3 | 4 |
+| ---------- | - | - | - | - | - |
+| dp\[1]\[k] | 0 | 1 | ∞ | ∞ | ∞ |
+
+---
+
+### i=2（a₂=3）
+
+* **使わない場合：** dpをそのまま
+* **使う場合：**
+
+```
+dp[2][3] = min(dp[2][3], dp[1][0]+1) => 1個（3だけ選択）
+dp[2][4] = min(dp[2][4], dp[1][1]+1) => 2個（1+3）
+```
+
+| k（和）       | 0 | 1 | 2 | 3 | 4 |
+| ---------- | - | - | - | - | - |
+| dp\[2]\[k] | 0 | 1 | ∞ | 1 | 2 |
+
+---
+
+### i=3（a₃=2）
+
+```
+dp[3][2] = min(∞, dp[2][0]+1) => 1個（2）
+dp[3][3] = min(1, dp[2][1]+1) => 1個（既にあるのでそのまま）
+dp[3][4] = min(2, dp[2][2]+1) => 2個（2+2）
+```
+
+| k（和）       | 0 | 1 | 2 | 3 | 4 |
+| ---------- | - | - | - | - | - |
+| dp\[3]\[k] | 0 | 1 | 1 | 1 | 2 |
+
+---
+
+### i=4（a₄=2）
+
+* 同様に更新されるが、`dp[3][k]`が最適なので更新なし（同じ値が入る）
+
+---
+
+### i=5（a₅=1）
+
+* 使わない場合：dp\[4]\[k]をコピー
+* 使う場合：
+
+```
+dp[5][1] = min(1, dp[4][0]+1) => 1
+dp[5][2] = min(1, dp[4][1]+1) => 1
+dp[5][3] = min(1, dp[4][2]+1) => 1
+dp[5][4] = min(2, dp[4][3]+1) => 2
+```
+
+---
+
+# 最終DPテーブル
+
+| k（和）       | 0 | 1 | 2 | 3 | 4 |
+| ---------- | - | - | - | - | - |
+| dp\[5]\[k] | 0 | 1 | 1 | 1 | 2 |
+
+---
+
+# 復元処理（`prev`配列を使う）
+
+* `dp[5][4]=2` →「和4を作るため、`prev[5][4]=3`」
+* `dp[5][3]=1` →「和3を作るため、`prev[5][3]=1`」
+
+### 復元した選択肢：
+
+```
+4 → 3 → 1 → 0
+```
+
+選んだ数：`3,1`
+（順番は逆でも良い）
+
+---
+
+# 処理フロー全体
+
+```plaintext
+初期化 dp[0][0]=0
+
+↓
+for i=1..N:
+   for k=0..K:
+       - 使わない場合 dp[i+1][k]=dp[i][k]
+       - 使う場合 dp[i+1][k+A[i]]=min(dp[i+1][k+A[i]], dp[i][k]+1)
+
+↓
+復元（prev配列から逆追跡）
+
+↓
+出力（個数 + 選んだ要素）
+```
+
+---
+
+# 図まとめ（状態遷移）
+
+```
+          i-1
+          |
+       ┌──┴──┐
+   使わない  使う
+     ↓        ↓
+  dp[i][k]   dp[i][k+A[i]] = min(dp[i][k+A[i]], dp[i-1][k]+1)
+```
+
+---
+
+# 計算量
+
+| 項目    | 値        |
+| ----- | -------- |
+| 時間計算量 | O(N × K) |
+| 空間計算量 | O(N × K) |
+
+---
+
+# メモリ・時間計測
+
+```javascript
+const startTime = process.hrtime.bigint();
+...（処理）...
+const endTime = process.hrtime.bigint();
+console.error(`Time: ${(endTime - startTime) / 1e6} ms`);
+
+const used = process.memoryUsage();
+console.error(`Memory: ${Math.round(used.heapUsed / 1024)} KB`);
+```
+
+---
+
+# まとめ
+
+| 処理     | 内容              |
+| ------ | --------------- |
+| DP配列   | 和kを作る最小個数を保持    |
+| prev配列 | 選んだ要素を復元するための履歴 |
+| 復元処理   | 和Kから逆に辿る        |
diff --git a/Algorithm/DynamicProgramming/other/Restore selected elements/Restore-selected-elements.js b/Algorithm/DynamicProgramming/other/Restore selected elements/Restore-selected-elements.js
new file mode 100644
index 00000000..8e15ea0e
--- /dev/null
+++ b/Algorithm/DynamicProgramming/other/Restore selected elements/Restore-selected-elements.js	
@@ -0,0 +1,133 @@
+// ご質問ありがとうございます。
+// 「**同じ位置の数字は複数回使えない場合**」は、\*\*部分和問題の典型的な制約付き版（0-1ナップサック問題）\*\*になります。
+
+// ---
+
+// ## 問題の違い：
+
+// | 条件     | 使える数字                      |
+// | ------ | -------------------------- |
+// | **前回** | 同じ数字は何度でも使える（無限個）          |
+// | **今回** | 同じ\*\*位置の数字は1回だけ使える（0-1制約） |
+
+// ---
+
+// ## 解法：
+
+// * 動的計画法（0-1ナップサック）
+// * `dp[i][k]` ：最初の i 個の数字から選んで和が k になるときの最小個数
+// * **復元用に`prev`配列を持つ**
+
+// ---
+
+// ## コード（Node.js）
+
+// ```javascript
+const fs = require('fs');
+
+/**
+ * 0-1制約付きの最小部分和問題
+ * @param {number} N - 数列の長さ
+ * @param {number} K - 目標の和
+ * @param {number[]} A - 数列A
+ * @returns {string} - 出力形式の文字列
+ */
+function minSubsetSum_01(N, K, A) {
+    const INF = 1e9;
+    const dp = Array.from({ length: N + 1 }, () => new Array(K + 1).fill(INF));
+    const prev = Array.from({ length: N + 1 }, () => new Array(K + 1).fill(-1)); // 復元用
+
+    dp[0][0] = 0;
+
+    for (let i = 0; i < N; i++) {
+        for (let k = 0; k <= K; k++) {
+            // i番目の要素を使わない場合
+            if (dp[i][k] < dp[i + 1][k]) {
+                dp[i + 1][k] = dp[i][k];
+                prev[i + 1][k] = k;
+            }
+            // i番目の要素を使う場合
+            if (k + A[i] <= K) {
+                if (dp[i][k] + 1 < dp[i + 1][k + A[i]]) {
+                    dp[i + 1][k + A[i]] = dp[i][k] + 1;
+                    prev[i + 1][k + A[i]] = k; // A[i]を使ってkからk+A[i]に遷移
+                }
+            }
+        }
+    }
+
+    if (dp[N][K] === INF) {
+        return '-1\n';
+    }
+
+    // 復元
+    const res = [];
+    let k = K;
+    for (let i = N; i >= 1; i--) {
+        if (prev[i][k] !== k) { // i番目の要素を使った場合
+            res.push(A[i - 1]);
+            k = prev[i][k];
+        }
+    }
+
+    return `${dp[N][K]}\n${res.join(' ')}\n`;
+}
+
+// 入力 & 計測
+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);
+
+const startTime = process.hrtime.bigint();
+const result = minSubsetSum_01(N, K, A);
+const endTime = process.hrtime.bigint();
+
+process.stdout.write(result);
+
+// パフォーマンス出力
+const used = process.memoryUsage();
+console.error(`Time: ${Number(endTime - startTime) / 1e6} ms`);
+console.error(`Memory: ${Math.round(used.heapUsed / 1024)} KB`);
+// ```
+
+// ---
+
+// ## 入力例と出力
+
+// ### 入力
+
+// ```
+// 5 4
+// 1 3 2 2 1
+// ```
+
+// ### 出力例
+
+// ```
+// 2
+// 1 3
+// ```
+
+// ※順序は任意（`3 1`でもOK）
+
+// ---
+
+// ## 制約まとめ：
+
+// * 各数字は**高々1回しか使えない**（同じ数字が複数あっても、同じ位置は1回だけ）
+// * 解法は **0-1ナップサックDP**
+
+// ---
+
+// ## 計算量：
+
+// * 時間計算量：O(N × K)
+// * 空間計算量：O(N × K)
+
+// ---
+
+// ## メモリと実行時間：
+
+// * `process.hrtime.bigint()`でナノ秒計測
+// * `process.memoryUsage()`でヒープ使用量出力
+
diff --git a/Algorithm/DynamicProgramming/other/Restore selected elements/Restore-selected-elements.py b/Algorithm/DynamicProgramming/other/Restore selected elements/Restore-selected-elements.py
new file mode 100644
index 00000000..68644e95
--- /dev/null
+++ b/Algorithm/DynamicProgramming/other/Restore selected elements/Restore-selected-elements.py	
@@ -0,0 +1,185 @@
+# 以下は「**0-1部分和問題（最小個数）」の**
+# **Python (CPython 3.11.4)** 解答例です。
+
+# ---
+
+# ## 解法：**動的計画法（0-1ナップサック）**
+
+# ### 特徴：
+
+# * **同じ位置の数字は1回だけ使用可能（0-1制約）**
+# * 最小個数で和`K`を作る
+# * 解が存在しなければ`-1`を出力
+# * **時間とメモリ使用量も計測**
+
+# ---
+
+# ## コード
+
+import sys
+import time
+import tracemalloc
+from typing import List, Tuple
+
+def min_subset_sum(N: int, K: int, A: List[int]) -> Tuple[int, List[int]]:
+    """
+    部分和最小個数問題（0-1ナップサック）の解法
+
+    Parameters:
+    - N : int
+    - K : int
+    - A : List[int]
+
+    Returns:
+    - Tuple[int, List[int]] : (最小個数, 選んだ要素のリスト)  
+      解なしなら (-1, [])
+    """
+    INF = 10**9
+    dp: List[List[int]] = [[INF] * (K + 1) for _ in range(N + 1)]
+    prev: List[List[int]] = [[-1] * (K + 1) for _ in range(N + 1)]
+
+    dp[0][0] = 0
+
+    for i in range(N):
+        for k in range(K + 1):
+            if dp[i][k] < dp[i + 1][k]:
+                dp[i + 1][k] = dp[i][k]
+                prev[i + 1][k] = k
+            if k + A[i] <= K:
+                if dp[i][k] + 1 < dp[i + 1][k + A[i]]:
+                    dp[i + 1][k + A[i]] = dp[i][k] + 1
+                    prev[i + 1][k + A[i]] = k
+
+    if dp[N][K] == INF:
+        return -1, []
+
+    # res の型を明示する
+    res: List[int] = []
+    k = K
+    for i in range(N, 0, -1):
+        if prev[i][k] != k:
+            res.append(A[i - 1])
+            k = prev[i][k]
+
+    return dp[N][K], res
+
+def main() -> None:
+    """
+    メイン実行関数。
+    標準入力からデータを受け取り、結果を標準出力に出力する。
+    また、処理時間とメモリ使用量を標準エラーに出力する。
+    """
+    input_data = sys.stdin.read().strip().split('\n')
+    N, K = map(int, input_data[0].split())
+    A = list(map(int, input_data[1].split()))
+
+    # 計測開始
+    start_time = time.perf_counter()
+    tracemalloc.start()
+
+    cnt, res = min_subset_sum(N, K, A)
+
+    # メモリ・時間計測終了
+    _, peak = tracemalloc.get_traced_memory()
+    tracemalloc.stop()
+    end_time = time.perf_counter()
+
+    # 結果出力
+    if cnt == -1:
+        print(-1)
+    else:
+        print(cnt)
+        print(' '.join(map(str, res)))
+
+    # パフォーマンス情報を標準エラー出力
+    print(f"Time: {(end_time - start_time)*1000:.3f} ms", file=sys.stderr)
+    print(f"Memory: {peak // 1024} KB", file=sys.stderr)
+
+if __name__ == "__main__":
+    main()
+# ```
+
+# ---
+
+# ## 入出力例：
+
+# ### 入力：
+
+# ```
+# 5 4
+# 1 3 2 2 1
+# ```
+
+# ### 出力：
+
+# ```
+# 2
+# 1 3
+# ```
+
+# または
+
+# ```
+# 2
+# 3 1
+# ```
+
+# （順序はどちらでもOK）
+
+# ---
+
+# ## 計測例（標準エラー出力）
+
+# ```
+# Time: 1.234 ms
+# Memory: 1500 KB
+# ```
+
+# ---
+
+# ## 処理時間・メモリ計測：
+
+# | 項目   | 使用                    |
+# | ---- | --------------------- |
+# | 処理時間 | `time.perf_counter()` |
+# | メモリ  | `tracemalloc`         |
+
+# ---
+
+# ## 計算量：
+
+# | 項目    | 値        |
+# | ----- | -------- |
+# | 時間計算量 | O(N × K) |
+# | 空間計算量 | O(N × K) |
+
+# ---
+
+# ## まとめ：
+
+# | 要素       | 内容                                 |
+# | -------- | ---------------------------------- |
+# | 使用言語     | Python (CPython 3.11.4)            |
+# | 型アノテーション | あり                                 |
+# | メモリ・時間計測 | `tracemalloc`, `time.perf_counter` |
+# | 入力       | 標準入力                               |
+# | 出力       | 標準出力、パフォーマンス情報は`stderr`            |
+
+# ---
+
+# ✅ これで解消する理由
+# res: List[int] と明示することで、
+# Pylanceが append の引数を「int型を追加している」と認識できるようになります。
+
+# Tuple[int, List[int]] と返り値の型も明示したため、Pylanceの推論が完全に行われます。
+
+# Pylance 型警告のよくある原因と対応
+# 原因	対応
+# append の型が不明	リストの型を明示する（List[int] など）
+# 戻り値が推論できない	関数の戻り値に -> 型 を必ず指定
+# 配列の初期化時に型が消える	List[List[int]] のように型付きで初期化
+
+# 🔍 補足
+# Pylanceは高速ですが、型推論が途中で途切れると Unknown を返すことがあります。
+# --strict モードなどを使うとこういった警告が頻繁に出るため、必ず型注釈を入れましょう。
+
diff --git a/DataStructures/Stacks/leetcode/20. Valid Parentheses/README.md b/DataStructures/Stacks/leetcode/20. Valid Parentheses/README.md
new file mode 100644
index 00000000..58541aaa
--- /dev/null
+++ b/DataStructures/Stacks/leetcode/20. Valid Parentheses/README.md	
@@ -0,0 +1,188 @@
+**スタックを用いた括弧検証アルゴリズム**を図解し、各処理について具体的に説明します。
+---
+
+# ① 基本的な動作フロー
+
+### **アルゴリズム概要**
+
+| 入力文字 | 動作         | スタック          |
+| ---- | ---------- | ------------- |
+| `(`  | Push       | `[`(\`]       |
+| `[`  | Push       | `[`(\`\`\[\`] |
+| `]`  | Pop & チェック | `[`(\`]       |
+| `)`  | Pop & チェック | （空）           |
+
+---
+
+## **図解：入力 s = "(\[])"**
+
+```
+初期状態:
+stack = []
+```
+
+### ステップ1: `(` を読む → **Push**
+
+```
+stack: [
+    (
+]
+```
+
+---
+
+### ステップ2: `[` を読む → **Push**
+
+```
+stack: [
+    ( 
+    [
+]
+```
+
+---
+
+### ステップ3: `]` を読む → **Pop & チェック**
+
+```
+pop -> [
+
+bracketMap[']'] = [
+
+[ が取り出されたので OK
+
+stack: [
+    (
+]
+```
+
+---
+
+### ステップ4: `)` を読む → **Pop & チェック**
+
+```
+pop -> (
+
+bracketMap[')'] = (
+
+( が取り出されたので OK
+
+stack: []
+```
+
+---
+
+### **最終判定**
+
+* `stack` が空 → **true（有効な括弧列）**
+
+---
+
+# ② 入力が不正な場合（例："(\[)]"）
+
+| 入力文字 | 動作         | スタック                                  |
+| ---- | ---------- | ------------------------------------- |
+| `(`  | Push       | `[`(\`]                               |
+| `[`  | Push       | `[`(\`\`\[\`]                         |
+| `)`  | Pop & チェック | `[`(`] → **失敗**（対応括弧が `\[`, 期待は `(\`） |
+
+---
+
+## **図解：入力 s = "(\[)]"**
+
+```
+初期状態:
+stack = []
+```
+
+### ステップ1: `(` を読む → **Push**
+
+```
+stack: [
+    (
+]
+```
+
+---
+
+### ステップ2: `[` を読む → **Push**
+
+```
+stack: [
+    ( 
+    [
+]
+```
+
+---
+
+### ステップ3: `)` を読む → **Pop & チェック**
+
+```
+pop -> [
+
+bracketMap[')'] = (
+
+[ が取り出されたが、期待は ( → **NG（不正）**
+
+即 return false
+```
+
+---
+
+# ③ 流れまとめ（フローチャート）
+
+```
+          +----------------+
+          | 文字列を1文字ずつ読む |
+          +--------+-------+
+                   |
+        +----------+-----------+
+        | 開き括弧か？         |
+        | (, [, {             |
+        +----------+-----------+
+                   |Yes
+          +--------v--------+
+          | スタックにPush   |
+          +-----------------+
+                   |
+                [次の文字]
+                   |
+                   |No（閉じ括弧）
+        +----------v----------+
+        | スタックが空か？    |
+        +----------+----------+
+                   |Yes
+          +--------v--------+
+          | 不正（false）   |
+          +----------------+
+                   |
+                   |No
+        +----------v-----------+
+        | スタックのTopと対応? |
+        +----------+-----------+
+                   |Yes         |No
+          +--------v--------+   +----------------+
+          | Popして次へ     |   | 不正（false） |
+          +-----------------+   +----------------+
+```
+
+---
+
+# ④ 時間・空間解析
+
+| 項目 | 計算量                      |
+| -- | ------------------------ |
+| 時間 | O(n)（1文字あたりPushまたはPopのみ） |
+| 空間 | O(n)（全て開き括弧のとき最大）        |
+
+---
+
+# ⑤ まとめ
+
+* **有効な括弧列**：スタックで管理し、**対応する閉じ括弧でTopが一致するか確認**
+* **不正な場合**：
+
+  * スタックが空の状態で閉じ括弧が来る
+  * スタックTopと閉じ括弧の対応が間違っている
+* **全処理後にスタックが空であれば正しい括弧列**
diff --git a/DataStructures/Stacks/leetcode/20. Valid Parentheses/ValidParentheses.js b/DataStructures/Stacks/leetcode/20. Valid Parentheses/ValidParentheses.js
new file mode 100644
index 00000000..530ca3d9
--- /dev/null
+++ b/DataStructures/Stacks/leetcode/20. Valid Parentheses/ValidParentheses.js	
@@ -0,0 +1,88 @@
+// 承知しました。
+// 以下は、指定された括弧の有効性判定問題を\*\*JavaScript（Node.js 18.16.1 / LeetCode対応）\*\*でクラスを使わず関数形式で解いた実装です。
+
+// ---
+
+// ## ✅ **問題再掲：**
+
+// **有効な括弧列**とは：
+
+// * `()[]{}` など、**開き括弧と閉じ括弧が正しく対応しているもの**
+// * 開いた順に対応する閉じ括弧で閉じられているもの
+
+// ---
+
+// ## 🔧 **実装（JavaScript）**
+
+// ```javascript
+/**
+ * 与えられた文字列sが有効な括弧列か判定する関数
+ * 
+ * @param {string} s - 入力文字列（括弧のみ： '()[]{}'）
+ * @returns {boolean} - 有効な括弧列ならtrue、不正ならfalse
+ * 
+ * 制約: 1 <= s.length <= 10^4
+ * 
+ * 時間計算量: O(n) （nは文字列の長さ）
+ * 空間計算量: O(n) （スタックを使用するため）
+ */
+function isValidJs(s) {
+    const stack = [];
+    
+    const bracketMap = {
+        ')': '(',
+        '}': '{',
+        ']': '['
+    };
+
+    for (let char of s) {
+        if (char === '(' || char === '{' || char === '[') {
+            stack.push(char);
+        } else {
+            if (stack.length === 0) {
+                return false;
+            }
+            const top = stack.pop();
+            if (top !== bracketMap[char]) {
+                return false;
+            }
+        }
+    }
+
+    return stack.length === 0;
+}
+// ```
+
+// ---
+
+// ## ✅ **実行例**
+
+// ```javascript
+// console.log(isValid("()"));       // true
+// console.log(isValid("()[]{}"));   // true
+// console.log(isValid("(]"));       // false
+// console.log(isValid("([])"));     // true
+// console.log(isValid("([)]"));     // false
+// ```
+
+// ---
+
+// ## 🔍 **処理時間・メモリ解析**
+
+// | 項目        | 計算量                 |
+// | --------- | ------------------- |
+// | **時間計算量** | O(n)（各文字を一度だけ処理）    |
+// | **空間計算量** | O(n)（スタック使用時の最大サイズ） |
+
+// ---
+
+// ## ⚙️ **LeetCode対応ポイント**
+
+// * **Node.js 18.16.1対応**
+// * クラスを使わず関数形式
+// * `console.log` によるテスト実行も可能
+// * `stack`を使うことで括弧の入れ子構造を適切に管理
+
+// ---
+
+// もし、追加で**図解やアルゴリズム解説、ブラウザ動作版**が欲しければ教えてください！
diff --git a/DataStructures/Stacks/leetcode/20. Valid Parentheses/ValidParentheses.py b/DataStructures/Stacks/leetcode/20. Valid Parentheses/ValidParentheses.py
new file mode 100644
index 00000000..28b17ff1
--- /dev/null
+++ b/DataStructures/Stacks/leetcode/20. Valid Parentheses/ValidParentheses.py	
@@ -0,0 +1,80 @@
+# 以下は、**LeetCode用のPython実装（CPython 3.11.4）**で、
+# 指定の括弧の妥当性判定を**クラス `Solution` 内メソッドで実装**したものです。
+
+# ## ✅ 実装コード（Python）
+
+# ```python
+from typing import List
+
+class Solution:
+    def isValid(self, s: str) -> bool:
+        """
+        与えられた文字列sが有効な括弧列か判定する関数
+
+        パラメーター:
+        s: str - 入力文字列（括弧のみ： '()[]{}'）
+
+        返却値:
+        bool - 有効な括弧列ならTrue、不正ならFalse
+
+        制約:
+        1 <= len(s) <= 10^4
+
+        時間計算量: O(n) （nは文字列長）
+        空間計算量: O(n) （スタック使用）
+        """
+        stack: List[str] = []
+        
+        bracket_map = {
+            ')': '(',
+            '}': '{',
+            ']': '['
+        }
+
+        for char in s:
+            if char in '({[':
+                stack.append(char)
+            else:
+                if not stack:
+                    return False
+                top = stack.pop()
+                if bracket_map[char] != top:
+                    return False
+
+        return not stack
+# ```
+
+# ---
+
+# ## ✅ **使用例（テストコード）**
+
+# ```python
+# # テスト実行例
+# solution = Solution()
+# print(solution.isValid("()"))        # True
+# print(solution.isValid("()[]{}"))    # True
+# print(solution.isValid("(]"))        # False
+# print(solution.isValid("([])"))      # True
+# print(solution.isValid("([)]"))      # False
+# ```
+
+# ---
+
+# ## 🔍 **解析**
+
+# | 項目        | 計算量                          |
+# | --------- | ---------------------------- |
+# | **時間計算量** | O(n) （各文字を一度だけ処理）            |
+# | **空間計算量** | O(n) （最悪ケースでスタックに全ての開き括弧が入る） |
+
+# ---
+
+# ## 🔧 **特徴**
+
+# * **LeetCode用構造** → `class Solution` に定義
+# * **型ヒント付き**（`List[str]`、`-> bool`）
+# * **最適化済み** → 余計な処理なし、シンプルかつ効率的
+
+# ---
+
+# もし、追加で**スタック動作の図解、再帰解法や例外ケースの説明**が必要であればお伝えください！
diff --git a/DataStructures/Stacks/leetcode/20. Valid Parentheses/ValidParentheses.ts b/DataStructures/Stacks/leetcode/20. Valid Parentheses/ValidParentheses.ts
new file mode 100644
index 00000000..28ec4cd5
--- /dev/null
+++ b/DataStructures/Stacks/leetcode/20. Valid Parentheses/ValidParentheses.ts	
@@ -0,0 +1,74 @@
+// 以下は、TypeScriptで括弧の妥当性を判定する関数実装です。
+// LeetCode環境(TypeScript 5.1, Node.js 18.16.1)に対応し、**クラスは使わず関数形式**で記述しています。
+
+// ### 処理時間とメモリ消費:
+
+// * **時間計算量**: O(n)（nは文字列長）
+// * **空間計算量**: O(n)（スタック使用）
+
+// ---
+
+// ```typescript
+/**
+ * 与えられた文字列が括弧として正しいかを判定する関数。
+ * 
+ * @param s - 入力文字列（'(', ')', '{', '}', '[', ']' からなる）
+ * @returns boolean - 正しい括弧列ならtrue、不正ならfalse
+ * 
+ * 制約: 1 <= s.length <= 10^4
+ * 時間計算量: O(n)
+ * 空間計算量: O(n)（スタックを使用するため）
+ */
+function isValid(s: string): boolean {
+    const stack: string[] = [];
+    
+    // 括弧の対応表
+    const bracketMap: Record<string, string> = {
+        ')': '(',
+        '}': '{',
+        ']': '[',
+    };
+
+    for (const char of s) {
+        // 開き括弧ならスタックにpush
+        if (char === '(' || char === '{' || char === '[') {
+            stack.push(char);
+        } else {
+            // 閉じ括弧の処理
+            if (stack.length === 0) {
+                return false; // 対応する開き括弧なし
+            }
+            const top = stack.pop();
+            if (top !== bracketMap[char]) {
+                return false; // 対応が間違っている
+            }
+        }
+    }
+
+    // 全ての括弧が閉じられているか
+    return stack.length === 0;
+}
+// ```
+
+// ---
+
+// ## 実行例:
+
+// ```typescript
+// console.log(isValid("()"));       // true
+// console.log(isValid("()[]{}"));   // true
+// console.log(isValid("(]"));       // false
+// console.log(isValid("([])"));     // true
+// console.log(isValid("([)]"));     // false
+// ```
+
+// ---
+
+// ## メモリ使用についての補足：
+
+// * **最悪ケース**（全て開き括弧の場合）でスタックに最大 `n` 個要素を保持するため、O(n) メモリを消費します。
+// * LeetCode環境では 10^4程度の文字列長でも十分実行可能です。
+
+// ---
+
+// もし図解や、実行時スタックの動作説明が必要であれば教えてください！