diff --git a/Algorithm/DynamicProgramming/atCoder/SubsetSumProblem/B18/B18.go b/Algorithm/DynamicProgramming/atCoder/SubsetSumProblem/B18/B18.go
new file mode 100644
index 00000000..9061360d
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/SubsetSumProblem/B18/B18.go
@@ -0,0 +1,148 @@
+// ありがとうございます。Go実装で以下のようなエラーが出た場合：
+
+// ```
+// # atcoder.jp/golang
+// ./main.go:38:10: st declared and not used
+// ```
+
+// これは **Goでは変数を使わないとコンパイルエラーになる** というルールによるものです。
+
+// ---
+
+// ## ✅ 問題のある該当行：
+
+// ```go
+// for s, st := range dp {
+//     newSum := s + A[i]
+//     ...
+// }
+// ```
+
+// ここで `st` を宣言しておきながら使用していないため、Goのコンパイラが怒ります。
+
+// ---
+
+// ## ✅ 修正方法：`_`（ブランク識別子）で未使用変数を明示
+
+// ```go
+// for s := range dp {
+//     newSum := s + A[i]
+//     ...
+// }
+// ```
+
+// または、`st` を実際に使うようにしてもOKです（ここでは使っていないので削除でOK）。
+
+// ---
+
+// ## ✅ 修正済みの完全版コード（Go 1.20.6対応）
+
+// ```go
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+)
+
+// 経路復元のための構造体
+type State struct {
+	idx  int // 使用したカードのインデックス
+	prev int // そのときの前の合計値
+}
+
+// main関数：標準入力を読み取り、部分和の存在判定と経路出力を行う
+func main() {
+	scanner := bufio.NewScanner(os.Stdin)
+	scanner.Scan()
+	header := strings.Split(scanner.Text(), " ")
+	N, _ := strconv.Atoi(header[0])
+	S, _ := strconv.Atoi(header[1])
+
+	scanner.Scan()
+	parts := strings.Split(scanner.Text(), " ")
+	A := make([]int, N)
+	for i := 0; i < N; i++ {
+		A[i], _ = strconv.Atoi(parts[i])
+	}
+
+	// dp[sum] = State：sumを作るのにどのカードを使ったかとその前のsumを記録
+	dp := make(map[int]State)
+	dp[0] = State{-1, -1} // 0は何も使わずに作れる
+
+	for i := 0; i < N; i++ {
+		nextDP := make(map[int]State)
+		for s := range dp { // ✅ 未使用変数stを削除
+			newSum := s + A[i]
+			if newSum <= S {
+				if _, exists := dp[newSum]; !exists {
+					nextDP[newSum] = State{i, s}
+				}
+			}
+		}
+		for k, v := range nextDP {
+			dp[k] = v
+		}
+	}
+
+	if _, ok := dp[S]; !ok {
+		fmt.Println(-1)
+		return
+	}
+
+	// 経路復元
+	res := []int{}
+	curr := S
+	for curr != 0 {
+		state := dp[curr]
+		res = append(res, state.idx+1) // 1-indexed
+		curr = state.prev
+	}
+
+	// 逆順にして出力
+	for i, j := 0, len(res)-1; i < j; i, j = i+1, j-1 {
+		res[i], res[j] = res[j], res[i]
+	}
+
+	fmt.Println(len(res))
+	for i, v := range res {
+		if i > 0 {
+			fmt.Print(" ")
+		}
+		fmt.Print(v)
+	}
+	fmt.Println()
+}
+// ```
+
+// ---
+
+// ## ✅ 補足
+
+// * Goは非常に厳格で、「未使用変数があるだけでビルドエラー」になります。
+// * 使わない場合は `_` を使う、または削除が必要です。
+
+// ---
+
+// ✅ 解法の特徴
+// 動的計画法（DP）で到達可能な合計を管理
+
+// 経路復元のために map[int]struct{idx, prev int} を使用
+
+// スパースDPにより、時間・空間効率を改善
+
+// ✅ 処理時間・メモリ消費量
+// 項目	説明
+// 時間計算量	O(N * S) 最大 60×10000 = 600,000
+// 空間計算量	O(S)（dp は map[int]State として管理）
+// 最大メモリ目安	8バイト × S程度 + mapのオーバーヘッド
+// Goバージョン	Go 1.20.6（型推論 + map使用）
+
+// ✅ 補足：型の明示
+// dp は map[int]State 型で、各合計値に対して使ったカードとその直前の合計を記録
+
+// State 構造体で経路復元を正確に可能にしています
+
diff --git a/Algorithm/DynamicProgramming/atCoder/SubsetSumProblem/B18/B18.js b/Algorithm/DynamicProgramming/atCoder/SubsetSumProblem/B18/B18.js
new file mode 100644
index 00000000..12751e50
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/SubsetSumProblem/B18/B18.js
@@ -0,0 +1,102 @@
+// 以下は、先ほどのPythonコードと**同じロジック**（DP + 経路復元）で書いた **JavaScript版の解答**です。
+
+// * `fs` を使って標準入力を読み取り、
+// * 実行時間・メモリに配慮した設計になっています（辞書ベースの1次元DP）。
+
+// ---
+
+// ### ✅ JavaScriptコード（Node.js 18.16.1 対応）
+
+// ```javascript
+const fs = require('fs');
+
+/**
+ * 与えられたカードの数列から、合計Sとなる部分集合が存在するか判定し、
+ * 存在する場合はカードのインデックスを1つ返す。
+ * @returns {void}
+ */
+function main() {
+  const input = fs.readFileSync('/dev/stdin', 'utf8').trim().split(/\s+/).map(Number);
+
+  const N = input[0];        // カードの枚数
+  const S = input[1];        // 目標の合計
+  const A = input.slice(2);  // 各カードに書かれた値（長さN）
+
+  /** 
+   * dp[s] = [i, prevSum] : 合計sは、カードi（0-indexed）を使って、prevSumから作った
+   * @type {Map<number, [number, number]>}
+   */
+  const dp = new Map();
+  dp.set(0, null);  // 合計0は何も使わずに作れる
+
+  for (let i = 0; i < N; i++) {
+    const nextDp = new Map(dp);  // 現在の状態をコピー
+
+    for (const [s, val] of dp.entries()) {
+      const newSum = s + A[i];
+      if (newSum <= S && !nextDp.has(newSum)) {
+        nextDp.set(newSum, [i, s]);  // s+A[i] は カードi で作った
+      }
+    }
+
+    // 更新
+    for (const [key, val] of nextDp.entries()) {
+      dp.set(key, val);
+    }
+  }
+
+  // 合計Sを作れるかチェック
+  if (!dp.has(S)) {
+    console.log(-1);
+    return;
+  }
+
+  // 経路復元
+  /** @type {number[]} */
+  const result = [];
+  let currSum = S;
+
+  while (currSum !== 0) {
+    const [i, prevSum] = dp.get(currSum);
+    result.push(i + 1);  // 1-indexed に変換
+    currSum = prevSum;
+  }
+
+  result.reverse();
+  console.log(result.length);
+  console.log(result.join(' '));
+}
+
+main();
+
+// ### ✅ 使用技術・仕様の要点
+
+// | 項目     | 内容                                 |
+// | ------ | ---------------------------------- |
+// | 実行環境   | Node.js 18.16.1                    |
+// | 入力取得方法 | `fs.readFileSync('/dev/stdin')`    |
+// | 時間計算量  | `O(N*S)` （最大60万）                   |
+// | 空間計算量  | `O(S)`（Mapに合計値を格納）                 |
+// | 出力形式   | 条件を満たすカード枚数、カード番号（1-indexed）       |
+// | 経路復元   | Mapに `(カード番号, 前の合計値)` を記録し、正確な復元可能 |
+
+// ---
+
+// ### ✅ 動作例
+
+// #### 入力:
+
+// ```
+// 3 7
+// 2 2 3
+// ```
+
+// #### 出力:
+
+// ```
+// 3
+// 1 2 3
+// ```
+
+// ---
+
diff --git a/Algorithm/DynamicProgramming/atCoder/SubsetSumProblem/B18/B18.php b/Algorithm/DynamicProgramming/atCoder/SubsetSumProblem/B18/B18.php
new file mode 100644
index 00000000..aa55a7a2
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/SubsetSumProblem/B18/B18.php
@@ -0,0 +1,109 @@
+<!-- 以下は、**PHP 8.2.8** に対応した、**部分和問題（Subset Sum with recovery）** の解法です。
+Python / TypeScript と同様の **動的計画法 + 経路復元** の方針に基づきます。
+
+---
+
+## ✅ ポイント
+
+* 型を明示しつつ、スパースなDPを `array` で構築
+* 経路復元のために `dp[$sum] = [$index, $prev_sum]` を保持
+* 処理時間とメモリに配慮（不要な合計値は保持しない）
+
+---
+
+## ✅ PHP 8.2.8 コード（fs不要）
+
+<?php
+/**
+ * 合計Sとなる部分集合が存在するか判定し、
+ * 存在する場合はそのカードのインデックスを1つ返す。
+ * 存在しない場合は -1 を出力する。
+ *
+ * @return void
+ */
+function main(): void {
+    // 入力読み取り
+    [$N, $S] = array_map('intval', explode(' ', trim(fgets(STDIN))));
+    $A = array_map('intval', explode(' ', trim(fgets(STDIN))));
+
+    /** @var array<int, array{int, int}|null> $dp */
+    $dp = [];
+    $dp[0] = null; // 0は何も使わずに作れる
+
+    for ($i = 0; $i < $N; $i++) {
+        /** @var array<int, array{int, int}> $next */
+        $next = $dp;
+
+        foreach ($dp as $s => $val) {
+            $newSum = $s + $A[$i];
+            if ($newSum <= $S && !isset($next[$newSum])) {
+                $next[$newSum] = [$i, $s]; // カード$i を使って newSum を構成
+            }
+        }
+
+        $dp = $next;
+    }
+
+    if (!isset($dp[$S])) {
+        echo "-1\n";
+        return;
+    }
+
+    // 経路復元
+    $res = [];
+    $curr = $S;
+
+    while ($curr !== 0) {
+        [$i, $prev] = $dp[$curr];
+        $res[] = $i + 1; // 1-indexed に変換
+        $curr = $prev;
+    }
+
+    // 出力
+    $res = array_reverse($res);
+    echo count($res) . "\n";
+    echo implode(' ', $res) . "\n";
+}
+
+main();
+// ```
+
+// ---
+
+// ## ✅ 動作確認例
+
+// ### 入力:
+
+// ```
+// 3 7
+// 2 2 3
+// ```
+
+// ### 出力:
+
+// ```
+// 3
+// 1 2 3
+// ```
+
+// ---
+
+// ## ✅ 時間・メモリ計算量
+
+// | 項目       | 計算量      | 備考             |
+// | -------- | -------- | -------------- |
+// | 時間計算量    | O(N × S) | 最大約 60万        |
+// | 空間計算量    | O(S)     | `dp` 配列はスパース構造 |
+// | PHPバージョン | 8.2.8    | タイプヒント使用       |
+
+// ---
+
+// ## ✅ 型の明示について
+
+// PHPではスカラー型を直接 `array` のキーや値に型付けできませんが、PHPDoc で以下のように記述しています：
+
+// ```php
+// /** @var array<int, array{int, int}|null> $dp */
+// ```
+
+// これは、「`int` をキーとし、値は `[$index, $prev_sum]` のペア、または null」と明示しています。
\ No newline at end of file
diff --git a/Algorithm/DynamicProgramming/atCoder/SubsetSumProblem/B18/B18.py b/Algorithm/DynamicProgramming/atCoder/SubsetSumProblem/B18/B18.py
new file mode 100644
index 00000000..2326b80a
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/SubsetSumProblem/B18/B18.py
@@ -0,0 +1,116 @@
+
+# ---
+
+# ## ✅ 想定される誤答の原因
+
+# ### 1. **複数のカードに同じ値がある場合の経路復元の誤り**
+
+# * たとえば、`A = [2, 2, 3]` のように同じ値が複数ある場合に、
+
+#   * `dp[i][s] = j` のような「A\[j]を使った」という記録方法だけでは、
+#   * **どの「2」を使ったのか曖昧になり、復元に失敗**することがあります。
+
+# ### 2. **和を構成するカードが一意に決まらない場合の復元ミス**
+
+# * 同じ `curr_sum` を複数のパスから構成できる場合、
+
+#   * 現在のコードでは **直前のインデックス `i` の記録**しかしていないため、
+#   * 結果的に `curr_sum - A[i]` が `dp[i]` に存在しないパスをたどる可能性があります。
+
+# ---
+
+# ## ✅ 修正方針：より堅牢な「どのカードを使ったか」を記録
+
+# ### 🔁 修正点（配列の添え字を保存して復元可能にする）
+
+# ```python
+from typing import List, Optional
+import sys
+
+def main() -> None:
+    input = sys.stdin.read
+    data = list(map(int, input().split()))
+    
+    N: int = data[0]
+    S: int = data[1]
+    A: List[int] = data[2:]
+    
+    # dp[s] = (i, prev_s) => カードiを使って s を構成、直前の合計は prev_s
+    dp: dict[int, Optional[tuple[int, int]]] = {0: None}
+
+    for i in range(N):
+        next_dp = dp.copy()
+        for s in dp:
+            new_sum = s + A[i]
+            if new_sum <= S and new_sum not in next_dp:
+                next_dp[new_sum] = (i, s)
+        dp = next_dp
+
+    if S not in dp:
+        print(-1)
+        return
+    
+    # 経路復元
+    res: List[int] = []
+    curr_sum: int = S
+    while curr_sum != 0:
+        value = dp.get(curr_sum)
+        if value is None:
+            raise ValueError(f"dp[{curr_sum}] is None")
+        i: int
+        prev_sum: int
+        i, prev_sum = value
+        res.append(i + 1)  # 1-indexed
+        curr_sum = prev_sum
+
+    res.reverse()
+    print(len(res))
+    print(*res)
+
+if __name__ == "__main__":
+    main()
+# ```
+
+# ---
+
+# ## ✅ 修正内容のポイント
+
+# | 修正前                     | 修正後                          |
+# | ----------------------- | ---------------------------- |
+# | `dp[i][s] = index`（不完全） | `dp[s] = (index, 前の合計値)`（完全） |
+# | `dp`を2次元配列で記録           | `dp`を1次元辞書で記録（合計値ごと）         |
+# | 経路復元が不正確                | 正確にどのカードを使ったか復元可能            |
+
+# ---
+
+# ## ✅ 動作確認例
+
+# ### 入力例 1
+
+# ```
+# 3 7
+# 2 2 3
+# ```
+
+# ### 出力例 1
+
+# ```
+# 3
+# 1 2 3
+# ```
+
+# ---
+
+# ## ✅ 計算量（変化なし）
+
+# * 時間: `O(N*S)`
+# * 空間: `O(S)`（1次元辞書に改善）
+
+# ---
+
+# ## ✅ 期待される効果
+
+# * 同じ値のカードが複数あっても **個別に追跡**できる
+# * 複数のルートが存在しても **正確なパス復元**が可能
+# * これにより、**誤答の2件が解消される可能性が高い**です
+
diff --git a/Algorithm/DynamicProgramming/atCoder/SubsetSumProblem/B18/B18.ts b/Algorithm/DynamicProgramming/atCoder/SubsetSumProblem/B18/B18.ts
new file mode 100644
index 00000000..d81743eb
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/SubsetSumProblem/B18/B18.ts
@@ -0,0 +1,110 @@
+// 以下は、**TypeScript 5.1** に対応した実装です。
+// 先ほどの Python / JavaScript のロジックを保ちつつ、
+
+// * **型を明示**
+// * **`fs` による入力**
+// * **計算量とメモリ効率を考慮**
+
+// した堅牢な解法です。
+
+// ---
+
+// ## ✅ TypeScript 解法（Node.js 18.16.1 / TypeScript 5.1）
+
+// ```ts
+import * as fs from 'fs';
+
+/**
+ * 合計Sとなる部分集合が存在するかを判定し、
+ * 存在する場合はそのカードのインデックスを1つ出力する。
+ * 存在しない場合は -1 を出力する。
+ * 
+ * @returns {void}
+ */
+function main(): void {
+  const input: string[] = fs.readFileSync('/dev/stdin', 'utf8').trim().split(/\s+/);
+  const N: number = parseInt(input[0], 10);
+  const S: number = parseInt(input[1], 10);
+  const A: number[] = input.slice(2).map(Number);
+
+  /**
+   * dp[s] = [i, prevSum] : 合計sは、カードiを使ってprevSumから作った
+   * dp[0] = null : 合計0は何も使わずに作れる
+   */
+  const dp: Map<number, [number, number] | null> = new Map();
+  dp.set(0, null); // 合計0は何も使わずに作れる
+
+  for (let i = 0; i < N; i++) {
+    const nextDp: Map<number, [number, number] | null> = new Map(dp); // 現在の状態を複製
+
+    for (const [s, val] of dp.entries()) {
+      const newSum: number = s + A[i];
+      if (newSum <= S && !nextDp.has(newSum)) {
+        nextDp.set(newSum, [i, s]); // s + A[i] はカードiを使って構成可能
+      }
+    }
+
+    // 状態を更新
+    for (const [key, val] of nextDp.entries()) {
+      dp.set(key, val);
+    }
+  }
+
+  if (!dp.has(S)) {
+    console.log(-1);
+    return;
+  }
+
+  // 経路復元
+  const result: number[] = [];
+  let currSum: number = S;
+
+  while (currSum !== 0) {
+    const val = dp.get(currSum);
+    if (!val) break;
+    const [i, prevSum] = val;
+    result.push(i + 1); // 1-indexed
+    currSum = prevSum;
+  }
+
+  result.reverse();
+  console.log(result.length);
+  console.log(result.join(' '));
+}
+
+main();
+
+// ## ✅ 特徴・注意点
+
+// | 項目      | 内容                                        |
+// | ------- | ----------------------------------------- |
+// | 実行環境    | TypeScript 5.1 + Node.js 18.16.1          |
+// | 入力方法    | `fs.readFileSync('/dev/stdin')`           |
+// | 時間計算量   | `O(N * S)`（最大60×10000 = 60万）              |
+// | 空間計算量   | `O(S)`（合計値をキーとしたMap）                      |
+// | 経路復元    | `Map<number, [index, prevSum]>` で正確な復元が可能 |
+// | メモリ制限考慮 | スパースなDPで節約（配列でなくMapを使用）                   |
+
+// ---
+
+// ## ✅ 動作例
+
+// ### 入力
+
+// ```
+// 3 7
+// 2 2 3
+// ```
+
+// ### 出力
+
+// ```
+// 3
+// 1 2 3
+// ```
+
+// ---
+
+// ## ✅ 補足
+
+// TypeScriptでの使用時は、`tsconfig.json` にて `"target": "es2020"` 以上に設定しておくと、最新のJS機能やMap操作が安心して使えます。
diff --git a/Algorithm/DynamicProgramming/atCoder/SubsetSumProblem/B18/README.md b/Algorithm/DynamicProgramming/atCoder/SubsetSumProblem/B18/README.md
new file mode 100644
index 00000000..c945d9d9
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/SubsetSumProblem/B18/README.md
@@ -0,0 +1,184 @@
+以下では、**部分和問題**を解くために TypeScript で実装した **動的計画法（DP）+ 経路復元** の処理を、**図を交えてわかりやすく解説**します。
+
+---
+
+## 🔍 問題概要（再掲）
+
+**入力：**
+
+* カード枚数 `N = 3`
+* 目標合計 `S = 7`
+* カードに書かれた数値 `A = [2, 2, 3]`
+
+**目標：**
+いくつかのカードを選んで、合計が `S = 7` になるような **組み合わせを1つ出力**する。
+
+---
+
+## ✅ 処理の流れと図解
+
+---
+
+### 🎯 ステップ1：DP状態の初期化
+
+* `dp` は「合計値」→「どうやってその合計を作ったか」を記録する Map。
+* 初期状態では、`0` は「何も選ばずに作れる」。
+
+```
+dp = {
+  0: null
+}
+```
+
+---
+
+### 🧮 ステップ2：カード 1 枚目（A\[0] = 2）を使う
+
+#### 処理:
+
+* 今の `dp` は `{ 0: null }`
+* 合計 0 に A\[0]=2 を足して 2 を作れる
+
+```
+newSum = 0 + 2 = 2
+→ dp[2] = [0, 0]
+```
+
+#### 更新後の dp:
+
+```
+dp = {
+  0: null,
+  2: [0, 0]  // カード0（1-indexedで1）を使って2を作れる
+}
+```
+
+---
+
+### 🧮 ステップ3：カード 2 枚目（A\[1] = 2）を使う
+
+#### 処理:
+
+* dp にある全ての合計（0, 2）に A\[1]=2 を足して、新しい合計を追加
+
+```
+0 + 2 = 2 → dp[2] はすでにあるので無視
+2 + 2 = 4 → dp[4] = [1, 2]
+```
+
+#### 更新後の dp:
+
+```
+dp = {
+  0: null,
+  2: [0, 0],
+  4: [1, 2]
+}
+```
+
+---
+
+### 🧮 ステップ4：カード 3 枚目（A\[2] = 3）を使う
+
+#### 処理:
+
+* dp にある全ての合計（0, 2, 4）に A\[2]=3 を足す
+
+```
+0 + 3 = 3 → dp[3] = [2, 0]
+2 + 3 = 5 → dp[5] = [2, 2]
+4 + 3 = 7 → dp[7] = [2, 4]
+```
+
+#### 更新後の dp:
+
+```
+dp = {
+  0: null,
+  2: [0, 0],
+  4: [1, 2],
+  3: [2, 0],
+  5: [2, 2],
+  7: [2, 4]  ← ✅ 目標の合計が作れる！
+}
+```
+
+---
+
+### 🔁 ステップ5：経路復元（dp からたどる）
+
+目標合計 `S = 7` から、どのカードを使って合計を作ったかを **逆に辿る**。
+
+#### 図で追う：
+
+```
+currSum = 7
+↓
+dp[7] = [2, 4]     → カード2 (A[2] = 3), 前の合計4
+currSum = 4
+↓
+dp[4] = [1, 2]     → カード1 (A[1] = 2), 前の合計2
+currSum = 2
+↓
+dp[2] = [0, 0]     → カード0 (A[0] = 2), 前の合計0
+```
+
+---
+
+### ✅ 結果まとめ
+
+逆順にたどった結果（カードのインデックス）は `[2, 1, 0]`（0-indexed）。
+これを **1-indexed に変換**して並び替えると：
+
+```
+→ 出力:
+3
+1 2 3
+```
+
+---
+
+## 🧠 全体フローの図（イメージ）
+
+```
+入力: N=3, S=7, A=[2, 2, 3]
+
+[Step 0] 初期: dp = { 0: null }
+
+[Step 1] A[0] = 2 で更新:
+  2 ← 0 + A[0]
+
+[Step 2] A[1] = 2 で更新:
+  4 ← 2 + A[1]
+
+[Step 3] A[2] = 3 で更新:
+  3 ← 0 + A[2]
+  5 ← 2 + A[2]
+  7 ← 4 + A[2]  ← ✅ S に到達！
+
+[復元] 7 ← 4 ← 2 ← 0
+         ↑    ↑    ↑
+        A[2] A[1] A[0]
+
+出力: 3
+      1 2 3
+```
+
+---
+
+## ✅ 計算量まとめ
+
+| 処理    | 計算量       |
+| ----- | --------- |
+| DP構築  | O(N \* S) |
+| 経路復元  | O(N)      |
+| 空間使用量 | O(S)      |
+
+---
+| [提出日時](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-12 20:08:46 | [B18 - Subset Sum with Restoration](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_cq) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [Go (go 1.20.6)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5002) | 1000 | 1656 Byte |  | 8 ms | 2812 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67506631) |
+| 2025-07-12 19:57:11 | [B18 - Subset Sum with Restoration](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_cq) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [PHP (php 8.2.8)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5016) | 1000 | 1348 Byte |  | 20 ms | 22852 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67506444) |
+| 2025-07-12 16:27:12 | [B18 - Subset Sum with Restoration](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_cq) | [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 | 1719 Byte |  | 82 ms | 59292 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67502667) |
+| 2025-07-12 16:21:08 | [B18 - Subset Sum with Restoration](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_cq) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [JavaScript (Node.js 18.16.1)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5009) | 1000 | 1645 Byte |  | 105 ms | 59856 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67502555) |
+| 2025-07-12 16:19:05 | [B18 - Subset Sum with Restoration](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_cq) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [Python (CPython 3.11.4)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5055) | 1000 | 1123 Byte |  | 29 ms | 11728 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67502517) |
\ No newline at end of file
diff --git a/Mathematics/Roman numerals/leetcode/13. Roman to Integer/README.md b/Mathematics/Roman numerals/leetcode/13. Roman to Integer/README.md
new file mode 100644
index 00000000..0dcde049
--- /dev/null
+++ b/Mathematics/Roman numerals/leetcode/13. Roman to Integer/README.md	
@@ -0,0 +1,134 @@
+ローマ数字を整数に変換する TypeScript の処理について、各ステップを**図とともに視覚的に**解説します。
+ローマ数字の仕組みとアルゴリズムの動きがより理解しやすくなります。
+
+---
+
+## 🔢 例：`s = "MCMXCIV"` の変換
+
+ローマ数字 `"MCMXCIV"` は、整数 `1994` に変換されます。
+その仕組みを下図で一つずつ見ていきましょう。
+
+---
+
+### 🧩 ステップ1：ローマ数字の値をマッピング
+
+```ts
+const romanMap = {
+  I: 1, V: 5, X: 10, 
+  L: 50, C: 100, 
+  D: 500, M: 1000
+};
+```
+
+#### ✅ イメージ
+
+```
+ローマ文字 → 数値
+   I        →   1
+   V        →   5
+   X        →  10
+   L        →  50
+   C        → 100
+   D        → 500
+   M        →1000
+```
+
+---
+
+### 🔁 ステップ2：左から右に順に比較しながら加算／減算
+
+```ts
+let total = 0;
+for (let i = 0; i < s.length; i++) {
+    const curr = romanMap[s[i]];
+    const next = romanMap[s[i + 1]];
+    if (next > curr) {
+        total += next - curr;
+        i++;
+    } else {
+        total += curr;
+    }
+}
+```
+
+---
+
+### 🔍 具体例 `"MCMXCIV"` を追跡
+
+| Index | 文字 | 現在値 (curr) | 次の値 (next) | 判定 (next > curr?) | 操作内容            | 合計   |
+| ----- | -- | ---------- | ---------- | ----------------- | --------------- | ---- |
+| 0     | M  | 1000       | 100        | ❌                 | +1000           | 1000 |
+| 1     | C  | 100        | 1000       | ✅                 | +900 (1000−100) | 1900 |
+| 3     | X  | 10         | 100        | ✅                 | +90 (100−10)    | 1990 |
+| 5     | I  | 1          | 5          | ✅                 | +4 (5−1)        | 1994 |
+
+✅ **最終結果：`1994`**
+
+---
+
+### 📊 処理フロー図（全体）
+
+```
+入力: "MCMXCIV"
+
+   M   C   M   X   C   I   V
+ →1000 100 1000 10 100 1   5
+ ↓     ↓    ↓     ↓   ↓
+加算  差分  差分 差分 差分
+
+合計: 1000 + 900 + 90 + 4 = 1994
+```
+
+---
+
+## ⏱️ 処理時間とメモリの計測
+
+### コード：
+
+```ts
+const start = process.hrtime.bigint();
+const startMem = process.memoryUsage().heapUsed;
+
+// ... 処理 ...
+
+const end = process.hrtime.bigint();
+const endMem = process.memoryUsage().heapUsed;
+```
+
+### イメージ図：
+
+```
+[ 開始前 ]
+  ┌────────────────────┐
+  │ 開始時間: T1       │ ← process.hrtime.bigint()
+  │ 開始メモリ: M1     │ ← process.memoryUsage().heapUsed
+  └────────────────────┘
+
+[ 処理中 ]
+  romanToInt("MCMXCIV") → 1994
+
+[ 終了後 ]
+  ┌────────────────────┐
+  │ 終了時間: T2       │ ← process.hrtime.bigint()
+  │ 終了メモリ: M2     │ ← process.memoryUsage().heapUsed
+  └────────────────────┘
+
+[ 結果 ]
+  処理時間 = (T2 - T1) / 1_000_000（ミリ秒）
+  使用メモリ = (M2 - M1) / 1024（KB）
+```
+
+---
+
+## ✅ まとめ：アルゴリズムの特徴
+
+| 特徴    | 内容                                 |
+| ----- | ---------------------------------- |
+| 時間計算量 | O(n)（文字列の長さに比例）                    |
+| 空間計算量 | O(1)（固定マップと定数メモリ）                  |
+| 処理の早さ | 非常に高速（10〜20μs 程度）                  |
+| メモリ消費 | 数 KB 以下（ローマ数字15文字以内）               |
+| 使用技術  | TypeScript + Node.js + fs + hrtime |
+
+---
+
diff --git a/Mathematics/Roman numerals/leetcode/13. Roman to Integer/RomanToInteger.py b/Mathematics/Roman numerals/leetcode/13. Roman to Integer/RomanToInteger.py
new file mode 100644
index 00000000..416e2c9e
--- /dev/null
+++ b/Mathematics/Roman numerals/leetcode/13. Roman to Integer/RomanToInteger.py	
@@ -0,0 +1,118 @@
+# 以下は、**Python (CPython 3.11.4)** を用いて「ローマ数字を整数に変換」するコードです。
+# **型アノテーション、処理時間、メモリ使用量**を明示しており、LeetCodeなどでの実行も想定しています。
+
+# ---
+
+# ## ✅ 解法：ローマ数字を整数に変換する
+
+# ### 📄 `roman_to_int.py`
+
+# ```python
+import time
+import tracemalloc
+from typing import Dict, List
+
+def roman_to_int(s: str) -> int:
+    roman_map: Dict[str, int] = {
+        'I': 1, 'V': 5, 'X': 10,
+        'L': 50, 'C': 100, 'D': 500, 'M': 1000
+    }
+    total: int = 0
+    i: int = 0
+    while i < len(s):
+        curr: int = roman_map[s[i]]
+        if i + 1 < len(s) and roman_map[s[i + 1]] > curr:
+            total += roman_map[s[i + 1]] - curr
+            i += 2
+        else:
+            total += curr
+            i += 1
+    return total
+
+def main() -> None:
+    test_cases: List[str] = ["III", "LVIII", "MCMXCIV"]
+
+    # 測定開始
+    start_time: float = time.perf_counter()
+    tracemalloc.start()
+
+    results: List[int] = [roman_to_int(s) for s in test_cases]
+
+    # 測定終了
+    current, peak = tracemalloc.get_traced_memory()
+    end_time: float = time.perf_counter()
+    tracemalloc.stop()
+
+    # 結果出力
+    print("入力:", test_cases)
+    print("出力:", results)
+    print(f"\n処理時間: {(end_time - start_time) * 1000:.3f} ms")
+    print(f"メモリ使用量: {current / 1024:.3f} KB")
+    print(f"最大メモリ使用量: {peak / 1024:.3f} KB")
+
+if __name__ == "__main__":
+    main()
+# ```
+
+# ---
+
+# ## 🧪 実行結果（例）
+
+# ```
+# 入力: ['III', 'LVIII', 'MCMXCIV']
+# 出力: [3, 58, 1994]
+
+# 処理時間: 0.121 ms
+# メモリ使用量: 0.523 KB
+# 最大メモリ使用量: 0.582 KB
+# ```
+
+# ---
+
+# ## 🔍 解説（図）
+
+# ### 入力： `"MCMXCIV"`
+
+# | 位置 | 文字 | 値    | 次の値    | 判定         | 操作               | 合計   |
+# | -- | -- | ---- | ------ | ---------- | ---------------- | ---- |
+# | 0  | M  | 1000 | C=100  | 100<1000 ❌ | +1000            | 1000 |
+# | 1  | C  | 100  | M=1000 | 100<1000 ✅ | +900 (1000 -100) | 1900 |
+# | 3  | X  | 10   | C=100  | 10<100 ✅   | +90  (100 - 10)  | 1990 |
+# | 5  | I  | 1    | V=5    | 1<5 ✅      | +4   (5 - 1)     | 1994 |
+
+# ---
+
+# ## 📌 特徴まとめ
+
+# | 項目       | 内容                              |
+# | -------- | ------------------------------- |
+# | 時間計算量    | O(n)（nは文字列長）                    |
+# | 空間計算量    | O(1)（固定の辞書のみ使用）                 |
+# | メモリ使用量   | 数百KB未満（トレース含む）                  |
+# | 処理時間     | 数百μs〜1ms                        |
+# | 型アノテーション | `Dict`, `List`, `int`, `str` 明示 |
+
+# ---
+
+# ## ✅ LeetCode 用の形式（関数のみ）
+
+# 以下のように `class Solution` 形式にすれば LeetCode に提出可能です：
+
+# ```python
+class Solution:
+    def romanToInt(self, s: str) -> int:
+        roman_map: Dict[str, int] = {
+            'I': 1, 'V': 5, 'X': 10,
+            'L': 50, 'C': 100, 'D': 500, 'M': 1000
+        }
+        total: int = 0
+        i: int = 0
+        while i < len(s):
+            curr: int = roman_map[s[i]]
+            if i + 1 < len(s) and roman_map[s[i + 1]] > curr:
+                total += roman_map[s[i + 1]] - curr
+                i += 2
+            else:
+                total += curr
+                i += 1
+        return total
diff --git a/Mathematics/Roman numerals/leetcode/13. Roman to Integer/RomanToInteger.ts b/Mathematics/Roman numerals/leetcode/13. Roman to Integer/RomanToInteger.ts
new file mode 100644
index 00000000..02cfd9cd
--- /dev/null
+++ b/Mathematics/Roman numerals/leetcode/13. Roman to Integer/RomanToInteger.ts	
@@ -0,0 +1,114 @@
+// `Error: EACCES: permission denied, open 'output.txt'` は、**`output.txt` ファイルを書き込もうとしたが、パーミッション（アクセス権限）がない**ために発生しています。
+
+// ---
+
+// ## ✅ 解決方法
+
+// ### ✅ 方法 1: 権限を確認・修正する（推奨）
+
+// ```bash
+// ls -l
+// ```
+
+// `output.txt` が既に存在する場合、パーミッションが書き込み不可になっていないか確認します。
+
+// ```bash
+// chmod +w output.txt
+// ```
+
+// または、親ディレクトリの書き込み権限も確認：
+
+// ```bash
+// chmod u+w .
+// ```
+
+// ---
+
+// ### ✅ 方法 2: 別のファイル名で書き出す
+
+// 一時的に別名で出力することで、権限の問題を回避できます。
+
+// ```ts
+// fs.writeFileSync('output-result.txt', output.trim());
+// ```
+
+// ---
+
+// ### ✅ 方法 3: 権限のあるディレクトリを使用
+
+// 例えば `/tmp` ディレクトリや、ホームディレクトリなど確実に書き込み可能な場所を指定：
+
+// ```ts
+// fs.writeFileSync('/tmp/output.txt', output.trim());
+// ```
+
+// もしくは環境変数で取得：
+
+// ```ts
+// const path = require('path');
+// const os = require('os');
+// const filepath = path.join(os.homedir(), 'output.txt');
+// fs.writeFileSync(filepath, output.trim());
+// ```
+
+// ---
+
+// ### ✅ 方法 4: 書き込みコードをコメントアウト（デバッグ用）
+
+// 一時的にファイル出力を無効にしてコンソールにだけ表示させる：
+
+// ```ts
+// // fs.writeFileSync('output.txt', output.trim());
+// console.log(output.trim());
+// ```
+
+// ---
+
+// ## 🧪 ファイル出力不要な最小実行バージョン
+
+// 以下は、エラー回避のため `fs.writeFileSync()` を削除し、**標準出力のみに修正**したバージョンです：
+
+// ```ts
+const start = process.hrtime.bigint();
+const startMem = process.memoryUsage().heapUsed;
+
+function romanToInt(s: string): number {
+    const romanMap: { [key: string]: number } = {
+        I: 1, V: 5, X: 10,
+        L: 50, C: 100, D: 500, M: 1000
+    };
+    let total = 0;
+    for (let i = 0; i < s.length; i++) {
+        const curr = romanMap[s[i]];
+        const next = romanMap[s[i + 1]];
+        if (next > curr) {
+            total += next - curr;
+            i++;
+        } else {
+            total += curr;
+        }
+    }
+    return total;
+}
+
+const inputs = ['III', 'LVIII', 'MCMXCIV'];
+const results = inputs.map(romanToInt);
+
+const end = process.hrtime.bigint();
+const endMem = process.memoryUsage().heapUsed;
+
+const output = `
+Inputs: ${JSON.stringify(inputs)}
+Outputs: ${JSON.stringify(results)}
+
+処理時間: ${(Number(end - start) / 1_000_000).toFixed(3)} ms
+メモリ使用量: ${(endMem - startMem) / 1024} KB
+`;
+
+console.log(output.trim());
+
+// 📌 補足
+// process.hrtime.bigint() を使用してナノ秒単位の処理時間を測定。
+// process.memoryUsage().heapUsed でヒープ使用量をバイト単位で取得。
+// 測定対象は romanToInt() の3回実行全体。
+