diff --git a/Algorithm/DynamicProgramming/atCoder/bitDP/B23/B23.go b/Algorithm/DynamicProgramming/atCoder/bitDP/B23/B23.go
new file mode 100644
index 00000000..524a50fd
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/bitDP/B23/B23.go
@@ -0,0 +1,156 @@
+// 以下は、**Go 1.20.6** を用いた巡回セールスマン問題（TSP）の解法です。
+// ビットDPを用いて、全都市を一度ずつ訪問し出発地点に戻る最短距離を求めます。
+
+// ---
+
+// ## ✅ Go実装（main.go）
+
+// ```go
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"math"
+	"os"
+	"strconv"
+	"strings"
+)
+
+// Point 座標を表す構造体
+type Point struct {
+	x int
+	y int
+}
+
+// computeDistances は各都市間のユークリッド距離を前計算して返します。
+//
+// 引数:
+//   coords []Point: 都市の座標
+//
+// 戻り値:
+//   [][]float64: dist[i][j] := 都市iから都市jへの距離
+func computeDistances(coords []Point) [][]float64 {
+	N := len(coords)
+	dist := make([][]float64, N)
+	for i := 0; i < N; i++ {
+		dist[i] = make([]float64, N)
+		for j := 0; j < N; j++ {
+			dx := float64(coords[i].x - coords[j].x)
+			dy := float64(coords[i].y - coords[j].y)
+			dist[i][j] = math.Hypot(dx, dy)
+		}
+	}
+	return dist
+}
+
+// solveTSP はビットDPを使って巡回セールスマン問題の最短距離を返します。
+//
+// 引数:
+//   N int: 都市の数 (2 <= N <= 15)
+//   coords []Point: 都市の座標
+//
+// 戻り値:
+//   float64: 最短経路の長さ（誤差1e-3未満）
+func solveTSP(N int, coords []Point) float64 {
+	const INF = 1e18
+	dist := computeDistances(coords)
+
+	dp := make([][]float64, 1<<N)
+	for i := range dp {
+		dp[i] = make([]float64, N)
+		for j := range dp[i] {
+			dp[i][j] = INF
+		}
+	}
+	dp[1][0] = 0.0 // 都市0のみ訪問している状態
+
+	for s := 1; s < (1 << N); s++ {
+		for u := 0; u < N; u++ {
+			if (s>>u)&1 == 0 {
+				continue
+			}
+			for v := 0; v < N; v++ {
+				if (s>>v)&1 != 0 {
+					continue
+				}
+				ns := s | (1 << v)
+				if dp[ns][v] > dp[s][u]+dist[u][v] {
+					dp[ns][v] = dp[s][u] + dist[u][v]
+				}
+			}
+		}
+	}
+
+	// 全都市訪問後、都市0へ戻る
+	res := INF
+	full := (1 << N) - 1
+	for u := 1; u < N; u++ {
+		if cost := dp[full][u] + dist[u][0]; cost < res {
+			res = cost
+		}
+	}
+	return res
+}
+
+// main は標準入力を読み取り、TSPの最短距離を出力します。
+func main() {
+	scanner := bufio.NewScanner(os.Stdin)
+	scanner.Scan()
+	N, _ := strconv.Atoi(scanner.Text())
+
+	coords := make([]Point, N)
+	for i := 0; i < N; i++ {
+		scanner.Scan()
+		fields := strings.Fields(scanner.Text())
+		x, _ := strconv.Atoi(fields[0])
+		y, _ := strconv.Atoi(fields[1])
+		coords[i] = Point{x, y}
+	}
+
+	result := solveTSP(N, coords)
+	fmt.Printf("%.12f\n", result)
+}
+
+// ## ✅ 実行方法
+
+// ```bash
+// go run main.go < input.txt
+// ```
+
+// ### 入力例（input.txt）:
+
+// ```
+// 4
+// 0 0
+// 0 1
+// 1 0
+// 1 1
+// ```
+
+// ### 出力:
+
+// ```
+// 4.000000000000
+// ```
+
+// ---
+
+// ## 📊 処理量とメモリの見積もり
+
+// | 指標       | 値                               |
+// | -------- | ------------------------------- |
+// | 時間計算量    | `O(N^2 * 2^N)`（N=15で約50万回）      |
+// | 空間使用量    | 約 `N * 2^N * 8 Byte` ≒ 最大 4 MiB |
+// | 浮動小数誤差対策 | `math.Hypot` と `%.12f` で安全な出力   |
+
+// ---
+
+// ## ✅ この実装の特徴
+
+// * `math.Hypot(dx, dy)` による安全で精度の高い距離計算
+// * `[]float64` による省メモリなDPテーブル
+// * 都市数 N=15 まで十分高速に対応
+// * 誤差 1e-3 未満の出力精度を保証（`fmt.Printf("%.12f")`）
+
+// ---
diff --git a/Algorithm/DynamicProgramming/atCoder/bitDP/B23/B23.js b/Algorithm/DynamicProgramming/atCoder/bitDP/B23/B23.js
new file mode 100644
index 00000000..9bc575c1
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/bitDP/B23/B23.js
@@ -0,0 +1,80 @@
+// 以下は、Node.js (18.16.1) 環境で動作する、\*\*巡回セールスマン問題（TSP）\*\*をビットDPで解く実装です。
+// 距離は **ユークリッド距離**で計算し、すべての都市を訪れて元の都市に戻る最短距離を求めます。
+
+// ```javascript
+// Node.js (v18.16.1) における TSP の解法（ビットDP）
+// 実行時間制限: 10秒、メモリ制限: 1024MiB
+
+const fs = require('fs');
+
+/**
+ * 都市巡回セールスマン問題を解く関数
+ * @param {number} N - 都市の数
+ * @param {[number, number][]} coords - 都市の座標配列 (X, Y)
+ * @returns {number} - 最短距離（絶対/相対誤差10^-3未満で正解）
+ */
+function solveTSP(N, coords) {
+  const dist = Array.from({ length: N }, () => Array(N).fill(0));
+
+  // 距離を前計算
+  for (let i = 0; i < N; i++) {
+    for (let j = 0; j < N; j++) {
+      const dx = coords[i][0] - coords[j][0];
+      const dy = coords[i][1] - coords[j][1];
+      dist[i][j] = Math.hypot(dx, dy); // √(dx² + dy²)
+    }
+  }
+
+  const INF = Infinity;
+  const dp = Array.from({ length: 1 << N }, () => Array(N).fill(INF));
+
+  // 初期位置を全都市として開始（0都市からスタート）
+  dp[1][0] = 0;
+
+  for (let s = 1; s < (1 << N); s++) {
+    for (let u = 0; u < N; u++) {
+      if (!(s & (1 << u))) continue;
+      for (let v = 0; v < N; v++) {
+        if (s & (1 << v)) continue;
+        const ns = s | (1 << v);
+        dp[ns][v] = Math.min(dp[ns][v], dp[s][u] + dist[u][v]);
+      }
+    }
+  }
+
+  // 最後に戻る距離を加える
+  let res = INF;
+  for (let u = 1; u < N; u++) {
+    res = Math.min(res, dp[(1 << N) - 1][u] + dist[u][0]);
+  }
+
+  return res;
+}
+
+// 入力処理
+(function main() {
+  const input = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n');
+  const N = parseInt(input[0], 10);
+  const coords = input.slice(1).map(line => line.split(' ').map(Number));
+
+  const result = solveTSP(N, coords);
+
+  // 絶対誤差・相対誤差が 1e-3 未満になるように出力（12桁精度）
+  console.log(result.toFixed(12));
+})();
+
+// ### ✅ 解説
+
+// * **計算量**: `O(N^2 * 2^N)`（N=15 でも問題なし）
+// * **距離の計算**: `Math.hypot(dx, dy)` を使うと精度良くユークリッド距離を計算できます。
+// * **メモリ使用量**: 約 `N * 2^N * 8 byte`（最大約 4 MiB 程度）
+// * **誤差対策**: `toFixed(12)` で小数第12位まで出力
+
+// ### ✅ 実行例（入力: `input.txt` を指定）
+
+// ```bash
+// $ node main.js < input.txt
+// 4.000000000000
+// ```
+
+// 他の改善（例えば枝刈りやメモ化DFS）もありますが、今回の制約ならこのビットDPが最適です。必要があれば経路復元付きの実装も可能です。
diff --git a/Algorithm/DynamicProgramming/atCoder/bitDP/B23/B23.php b/Algorithm/DynamicProgramming/atCoder/bitDP/B23/B23.php
new file mode 100644
index 00000000..febd5732
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/bitDP/B23/B23.php
@@ -0,0 +1,129 @@
+<!-- 以下は、**PHP 8.2.8** を用いた「巡回セールスマン問題（TSP）」の解法です。
+ビットDP（状態：訪問済み都市集合×現在地）により、**全都市を訪問して出発地に戻る最短距離**を求めます。
+
+---
+
+## ✅ 実装（PHP 8.2.8、型・コメント付き）
+
+<?php
+
+declare(strict_types=1);
+
+/**
+ * 距離行列を計算する
+ *
+ * @param array<int, array{int, int}> $coords 各都市の座標 [(x1, y1), ..., (xN, yN)]
+ * @return array<int, array<int, float>> 距離行列 dist[i][j] = 都市iからjへの距離
+ */
+function computeDistances(array $coords): array {
+    $N = count($coords);
+    $dist = array_fill(0, $N, array_fill(0, $N, 0.0));
+    for ($i = 0; $i < $N; $i++) {
+        for ($j = 0; $j < $N; $j++) {
+            $dx = $coords[$i][0] - $coords[$j][0];
+            $dy = $coords[$i][1] - $coords[$j][1];
+            $dist[$i][$j] = hypot($dx, $dy);
+        }
+    }
+    return $dist;
+}
+
+/**
+ * 巡回セールスマン問題を解く
+ *
+ * @param int $N 都市の数 (2 <= N <= 15)
+ * @param array<int, array{int, int}> $coords 各都市の座標
+ * @return float 最短距離（誤差1e-3以内）
+ */
+function solveTSP(int $N, array $coords): float {
+    $dist = computeDistances($coords);
+    $INF = INF;
+
+    // dp[s][u] := 訪問済み集合s, 現在地u のときの最短距離
+    $dp = array_fill(0, 1 << $N, array_fill(0, $N, $INF));
+    $dp[1][0] = 0.0;
+
+    for ($s = 1; $s < (1 << $N); $s++) {
+        for ($u = 0; $u < $N; $u++) {
+            if (!(($s >> $u) & 1)) continue;
+            for ($v = 0; $v < $N; $v++) {
+                if (($s >> $v) & 1) continue;
+                $ns = $s | (1 << $v);
+                $dp[$ns][$v] = min($dp[$ns][$v], $dp[$s][$u] + $dist[$u][$v]);
+            }
+        }
+    }
+
+    $res = $INF;
+    for ($u = 1; $u < $N; $u++) {
+        $res = min($res, $dp[(1 << $N) - 1][$u] + $dist[$u][0]);
+    }
+
+    return $res;
+}
+
+/**
+ * 標準入力から座標情報を読み取り、solveTSP を呼び出すメイン関数
+ */
+function main(): void {
+    [$N] = sscanf(trim(fgets(STDIN)), "%d");
+    $coords = [];
+
+    for ($i = 0; $i < $N; $i++) {
+        [$x, $y] = sscanf(trim(fgets(STDIN)), "%d %d");
+        $coords[] = [$x, $y];
+    }
+
+    $result = solveTSP($N, $coords);
+
+    // 小数点以下12桁で出力（誤差1e-3対策）
+    printf("%.12f\n", $result);
+}
+
+main();
+
+// ## 🧪 実行方法
+
+// ```bash
+// php main.php < input.txt
+// ```
+
+// 例: `input.txt`
+
+// ```
+// 4
+// 0 0
+// 0 1
+// 1 0
+// 1 1
+// ```
+
+// 出力:
+
+// ```
+// 4.000000000000
+// ```
+
+// ---
+
+// ## 📊 計算量と制約への対応
+
+// | 項目       | 内容                             |
+// | -------- | ------------------------------ |
+// | 時間計算量    | `O(N^2 * 2^N)`（N≦15で約50万）      |
+// | 空間使用量    | `N * 2^N * float` ≒ 約4MiB      |
+// | 精度       | `hypot` + `printf("%.12f")` 使用 |
+// | PHPバージョン | 8.2.8（型指定、INF、hypot利用可）        |
+
+// ---
+
+// ## ✅ 特徴
+
+// * 型コメント・戻り値明示（`array{int, int}` 型タプル風）
+// * 安全で高速な `hypot()` による距離計算
+// * 浮動小数誤差に強い出力形式（12桁）
+// * 計算量・メモリ制限に完全準拠（N ≦ 15）
+
+// ---
+
+// ご希望があれば、**経路復元付き実装** や **部分メモ化付きDFS版** なども提供可能です。お気軽にどうぞ！
\ No newline at end of file
diff --git a/Algorithm/DynamicProgramming/atCoder/bitDP/B23/B23.py b/Algorithm/DynamicProgramming/atCoder/bitDP/B23/B23.py
new file mode 100644
index 00000000..275b159b
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/bitDP/B23/B23.py
@@ -0,0 +1,193 @@
+# 以下は、**Python (CPython 3.11.4)** を用いて、**巡回セールスマン問題 (TSP)** をビットDPで解く実装です。
+# 型アノテーション付きで、**処理時間・メモリ使用量を抑えつつ正確に解答**できるように設計しています。
+
+# ---
+
+# ## ✅ Python 解法（ビットDP）
+
+# ```python
+import sys
+import math
+from typing import List, Tuple, Sequence
+
+# 入力高速化
+sys.setrecursionlimit(1 << 25)
+
+from typing import Sequence
+
+def read_input() -> Tuple[int, List[Tuple[int, int]]]:
+    """標準入力を読み取り、都市数と座標リストを返す"""
+    input_lines = sys.stdin.read().splitlines()
+    N = int(input_lines[0])
+    coords: List[Tuple[int, int]] = [
+        (int(x), int(y)) for line in input_lines[1:] for x, y in [line.split()]
+    ]
+    return N, coords
+
+def compute_distances(coords: List[Tuple[int, int]]) -> List[List[float]]:
+    """各都市間のユークリッド距離を事前計算する"""
+    N = len(coords)
+    dist = [[0.0] * N for _ in range(N)]
+    for i in range(N):
+        for j in range(N):
+            dx = coords[i][0] - coords[j][0]
+            dy = coords[i][1] - coords[j][1]
+            dist[i][j] = math.hypot(dx, dy)
+    return dist
+
+def tsp(N: int, coords: List[Tuple[int, int]]) -> float:
+    """
+    巡回セールスマン問題をビットDPで解く
+    Parameters:
+        N (int): 都市の数 (2 <= N <= 15)
+        coords (List[Tuple[int, int]]): 都市の座標 [(x1, y1), ..., (xN, yN)]
+    Returns:
+        float: 最短経路の長さ（誤差1e-3未満で正確）
+    """
+    dist = compute_distances(coords)
+    INF = float('inf')
+    
+    # dp[s][u] := 訪問済み集合s、現在地u の最短距離
+    dp: List[List[float]] = [[INF] * N for _ in range(1 << N)]
+    dp[1][0] = 0.0  # 開始点は都市0のみ訪問
+
+    for s in range(1 << N):
+        for u in range(N):
+            if not (s & (1 << u)):
+                continue
+            for v in range(N):
+                if s & (1 << v):
+                    continue
+                ns = s | (1 << v)
+                dp[ns][v] = min(dp[ns][v], dp[s][u] + dist[u][v])
+
+    # 最後に出発点0に戻る
+    final_cost = INF
+    for u in range(1, N):
+        final_cost = min(final_cost, dp[(1 << N) - 1][u] + dist[u][0])
+
+    return final_cost
+
+def main() -> None:
+    N, coords = read_input()
+    coords_list: Sequence[Tuple[int, int]] = coords
+    result = tsp(N, list(coords_list))
+    # 小数点以下12桁まで出力（誤差対策）
+    print(f"{result:.12f}")
+
+if __name__ == "__main__":
+    main()
+# ```
+
+# ---
+
+# ## 📊 処理時間・メモリの見積もり
+
+# | 指標     | 値                                 |
+# | ------ | --------------------------------- |
+# | 時間計算量  | `O(N^2 * 2^N)`（N=15で \~5×10⁵ 以内）  |
+# | メモリ使用量 | 約 `N * 2^N * 8 Byte` ≒ 最大 4 MiB   |
+# | 精度     | `math.hypot()` + `print("%.12f")` |
+
+# ---
+
+# ## ✅ 使用方法
+
+# 入力ファイルを用意して、以下のように実行してください。
+
+# ### 実行例：
+
+# ```bash
+# python3 main.py < input.txt
+# ```
+
+# ### 入力例：
+
+# ```
+# 4
+# 0 0
+# 0 1
+# 1 0
+# 1 1
+# ```
+
+# ### 出力：
+
+# ```
+# 4.000000000000
+# ```
+
+# ---
+
+# ## 🔎 補足
+
+# * `math.hypot(dx, dy)` は `√(dx² + dy²)` を安全かつ高精度に計算します。
+# * 標準的なビットDPで、**都市数15まで対応**可能です。
+# * 精度（誤差 1e-3 未満）を担保するために `.12f` 形式で出力しています。
+
+# ---
+
+# 必要であれば、**経路の復元機能** や **部分メモ化** による高速化の提案も可能です。お気軽にどうぞ！
+
+# ご指摘の Type Checker（たとえば `mypy` や Pyright）による型エラーは、`tuple[int, ...]` が不定長タプルであり、`Tuple[int, int]` のような固定長タプルのシーケンスに代入できない、という理由によるものです。
+
+# ---
+
+# ## ✅ 原因の詳細
+
+# エラーメッセージの主な内容は以下の通りです：
+
+# ```
+# "tuple[int, ...]" は "Tuple[int, int]" に割り当てできません
+# Tuple のサイズが一致しません。2 が必要ですが、受け取りは不確定です
+# ```
+
+# これは、以下の行のリスト内包表現の `tuple(...)` の推論が `tuple[int, ...]`（任意長）になってしまうため：
+
+# ```python
+# coords = [tuple(map(int, line.split())) for line in input_lines[1:]]
+# ```
+
+# ---
+
+# ## ✅ 修正方法
+
+# 「行を空白で分割 → 2要素のタプルにする」という意図を明示するため、まず `split()` → `int` の変換 → 明示的な 2 要素タプルにすれば OK です。
+
+# ### 🔧 修正後のコード
+
+# ```python
+# def read_input() -> Tuple[int, List[Tuple[int, int]]]:
+#     """標準入力を読み取り、都市数と座標リストを返す"""
+#     input_lines = sys.stdin.read().splitlines()
+#     N = int(input_lines[0])
+#     coords: List[Tuple[int, int]] = [
+#         (int(x), int(y)) for line in input_lines[1:] for x, y in [line.split()]
+#     ]
+#     return N, coords
+# ```
+
+# ### ✅ 補足（より明示的な形でも OK）
+
+# ```python
+# def read_input() -> Tuple[int, List[Tuple[int, int]]]:
+#     input_lines = sys.stdin.read().splitlines()
+#     N = int(input_lines[0])
+#     coords: List[Tuple[int, int]] = []
+#     for line in input_lines[1:]:
+#         x_str, y_str = line.split()
+#         x, y = int(x_str), int(y_str)
+#         coords.append((x, y))
+#     return N, coords
+# ```
+
+# ---
+
+# ## ✅ 結論
+
+# * `tuple(map(...))` を使うと Python 側では `tuple[int, ...]` として推論され、mypy や Pyright では `Tuple[int, int]` と互換がないと判断されます。
+# * 型を通すには、**固定長の `(int, int)`** を明示的に構築してください。
+
+# ---
+
+# もし PEP 646 対応の型チェッカーを使っていた場合でも、実用上はこの修正で十分安全です。必要であればさらにリファクタも可能です。
diff --git a/Algorithm/DynamicProgramming/atCoder/bitDP/B23/B23.ts b/Algorithm/DynamicProgramming/atCoder/bitDP/B23/B23.ts
new file mode 100644
index 00000000..01db32c5
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/bitDP/B23/B23.ts
@@ -0,0 +1,115 @@
+// 以下は **TypeScript (5.1)** + **Node.js (18.16.1)** を用いた、**巡回セールスマン問題 (TSP)** をビットDPで解く解法です。
+// `fs` モジュールを使って標準入力を受け取り、計算量・メモリ制限を考慮した実装になっています。
+
+// ---
+
+// ### ✅ TypeScript 実装（`main.ts`）
+
+// ```ts
+import * as fs from 'fs';
+
+/**
+ * 都市巡回セールスマン問題を解く関数（ビットDP）
+ * @param N - 都市の数（2 <= N <= 15）
+ * @param coords - 都市の座標配列 [ [x1, y1], [x2, y2], ..., [xN, yN] ]
+ * @returns 最短距離（小数で返却）
+ */
+function solveTSP(N: number, coords: [number, number][]): number {
+  const dist: number[][] = Array.from({ length: N }, () => Array(N).fill(0));
+
+  // 距離を前計算（ユークリッド距離）
+  for (let i = 0; i < N; i++) {
+    for (let j = 0; j < N; j++) {
+      const dx = coords[i][0] - coords[j][0];
+      const dy = coords[i][1] - coords[j][1];
+      dist[i][j] = Math.hypot(dx, dy);
+    }
+  }
+
+  const INF = Infinity;
+  const dp: number[][] = Array.from({ length: 1 << N }, () => Array(N).fill(INF));
+  dp[1][0] = 0; // スタートは都市0（ビット1）
+
+  for (let s = 1; s < (1 << N); s++) {
+    for (let u = 0; u < N; u++) {
+      if (!(s & (1 << u))) continue;
+      for (let v = 0; v < N; v++) {
+        if (s & (1 << v)) continue;
+        const ns = s | (1 << v);
+        dp[ns][v] = Math.min(dp[ns][v], dp[s][u] + dist[u][v]);
+      }
+    }
+  }
+
+  let res = INF;
+  for (let u = 1; u < N; u++) {
+    res = Math.min(res, dp[(1 << N) - 1][u] + dist[u][0]); // 最後にスタートに戻る
+  }
+
+  return res;
+}
+
+// --- 入力処理と出力 ---
+function main(): void {
+  const input: string = fs.readFileSync('/dev/stdin', 'utf8').trim();
+  const lines: string[] = input.split('\n');
+  const N: number = Number(lines[0]);
+  const coords: [number, number][] = lines.slice(1).map(line => {
+    const [x, y] = line.split(' ').map(Number);
+    return [x, y];
+  });
+
+  const result = solveTSP(N, coords);
+  console.log(result.toFixed(12)); // 小数第12位まで出力
+}
+
+main();
+
+// ### ✅ 実行方法
+
+// 1. ファイル名を `main.ts` に保存
+// 2. TypeScript をコンパイル：
+
+// ```bash
+// tsc main.ts
+// ```
+
+// 3. 実行：
+
+// ```bash
+// node main.js < input.txt
+// ```
+
+// ---
+
+// ### ✅ メモリ・処理時間の見積もり
+
+// | 要素     | 値                               |
+// | ------ | ------------------------------- |
+// | 時間計算量  | `O(N^2 * 2^N)`（N=15で約500,000回）  |
+// | メモリ使用量 | 約 `8 * N * 2^N` byte（最大約 4 MiB） |
+// | 距離誤差対応 | `toFixed(12)` で出力誤差1e-3以下を保証    |
+
+// ---
+
+// ### ✅ 入出力例
+
+// #### 入力（例1）
+
+// ```
+// 4
+// 0 0
+// 0 1
+// 1 0
+// 1 1
+// ```
+
+// #### 出力
+
+// ```
+// 4.000000000000
+// ```
+
+// ---
+
+// 何か不明点や経路復元付きの実装などが必要であれば、お知らせください！
diff --git a/Algorithm/DynamicProgramming/atCoder/bitDP/B23/README.md b/Algorithm/DynamicProgramming/atCoder/bitDP/B23/README.md
new file mode 100644
index 00000000..ec9b31a5
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/bitDP/B23/README.md
@@ -0,0 +1,182 @@
+以下では、**ビットDPによる巡回セールスマン問題（TSP）の解法**について、図を交えながら**各処理の具体的な役割・仕組み**を丁寧に説明します。
+
+---
+
+## 🧭 問題概要（図解）
+
+与えられた複数の都市を **一度ずつ訪れて出発点に戻る** 最短ルートを求める。
+
+```
+例: 4都市の場合（座標省略）
+
+        (1)
+        / \
+      /     \
+    (0)     (3)
+      \     /
+        \ /
+        (2)
+
+最短経路の一例: 0 → 1 → 3 → 2 → 0
+```
+
+距離はすべて **ユークリッド距離**（直線距離）です。
+
+---
+
+## ✅ 解法全体の構造（ビットDP）
+
+TSPを **bitDP (状態:訪問済み集合 × 現在地)** で解きます。
+
+### 状態定義：
+
+```ts
+dp[S][u] := 訪問済み都市集合 S にいて、現在地が u のときの最短距離
+```
+
+* `S`: 訪問した都市のビットマスク（0〜(1<\<N)-1）
+* `u`: 現在いる都市のインデックス（0〜N-1）
+
+---
+
+## 🧩 ステップごとの詳細解説（図付き）
+
+---
+
+### 🥇 ステップ1：距離の前計算
+
+```ts
+dist[i][j] = √((xi - xj)^2 + (yi - yj)^2)
+```
+
+#### 図：
+
+```
+都市間の距離（例: 4都市）
+
+        0       1       2       3
+      +----------------------------+
+    0 |   0   d01    d02    d03
+    1 | d10     0    d12    d13
+    2 | d20   d21      0    d23
+    3 | d30   d31   d32      0
+```
+
+これを `N^2` 個、前もって計算します。
+
+---
+
+### 🥈 ステップ2：初期化
+
+```ts
+dp[1][0] = 0
+```
+
+#### 意味：
+
+* まだ都市 `0` しか訪れていない（= `0001`）
+* 現在地も都市 `0` → 距離は `0`
+
+---
+
+### 🥉 ステップ3：遷移（状態更新）
+
+```ts
+for (s = 1; s < 1<<N; s++) {
+  for (u = 0; u < N; u++) {
+    if (!(s & (1 << u))) continue;
+    for (v = 0; v < N; v++) {
+      if (s & (1 << v)) continue;
+      dp[s | (1 << v)][v] = min(dp[s | (1 << v)][v], dp[s][u] + dist[u][v]);
+    }
+  }
+}
+```
+
+---
+
+#### 図：状態遷移例（N = 3）
+
+* 状態: `dp[0b001][0] = 0`（都市0にいる）
+* 遷移:
+
+```
+           +---+ d[0][1] +---+ d[1][2] +---+
+Start(0) →| 1 |-------->| 1 |-------->| 2 |
+         [001][0]     [011][1]     [111][2]
+
+dp[011][1] = dp[001][0] + dist[0][1]
+dp[111][2] = dp[011][1] + dist[1][2]
+```
+
+* 全都市訪問後（状態: `111`）、`→ 0` に戻って最短経路を完成させる。
+
+---
+
+### 🏁 ステップ4：最終的な答え
+
+```ts
+let res = Infinity;
+for (let u = 1; u < N; u++) {
+  res = Math.min(res, dp[(1 << N) - 1][u] + dist[u][0]);
+}
+```
+
+#### 図：
+
+```
+各都市で最後に止まり、出発地0へ戻る経路を考慮：
+
+dp[111][1] + dist[1][0]
+dp[111][2] + dist[2][0]
+dp[111][3] + dist[3][0]
+           ︙
+→ その最小値が答え
+```
+
+---
+
+## 🧠 実際の DP 表の例（N=3）
+
+```
+dp[bit][city] = 最短距離
+
+bit = 訪問済み都市集合（例: 011 = 都市0と1を訪問）
+
+初期: dp[001][0] = 0
+
+更新例:
+
+dp[011][1] = dp[001][0] + dist[0][1]
+dp[111][2] = dp[011][1] + dist[1][2]
+dp[111][1] = dp[101][2] + dist[2][1]
+...
+```
+
+---
+
+## ⚙ 処理量と制約内での対応
+
+| 項目     | 値                    |
+| ------ | -------------------- |
+| 状態数    | `N * 2^N`            |
+| 遷移数    | `N^2 * 2^N`          |
+| 時間計算量  | 約 `7.5 * 10^5`（N=15） |
+| メモリ使用量 | 約 4 MiB              |
+| 計算精度   | `toFixed(12)` 使用     |
+
+---
+
+## ✅ 結論：この解法の強み
+
+* 精度良く計算可能（誤差1e-3未満）
+* 時間・メモリ制約を満たす（N=15まで余裕）
+* 経路復元も拡張可能
+
+| [提出日時](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-16 15:51:43 | [B23 - Traveling Salesman Problem](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_cv) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [Go (go 1.20.6)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5002) | 1000 | 2318 Byte |  | 23 ms | 6844 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67638699) |
+| 2025-07-16 15:41:19 | [B23 - Traveling Salesman Problem](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_cv) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [PHP (php 8.2.8)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5016) | 1000 | 2158 Byte |  | 101 ms | 34160 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67638408) |
+| 2025-07-16 15:34:31 | [B23 - Traveling Salesman Problem](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_cv) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [Python (CPython 3.11.4)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5055) | 1000 | 2332 Byte |  | 553 ms | 20796 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67638210) |
+| 2025-07-16 15:14:45 | [B23 - Traveling Salesman Problem](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_cv) | [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 | 1835 Byte |  | 87 ms | 59288 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67637678) |
+| 2025-07-16 15:08:08 | [B23 - Traveling Salesman Problem](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_cv) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [JavaScript (Node.js 18.16.1)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5009) | 1000 | 1854 Byte |  | 89 ms | 59600 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67637515) |
\ No newline at end of file
diff --git a/Algorithm/TwoPointers/leetcode/16. 3Sum Closest/3SumClosest.py b/Algorithm/TwoPointers/leetcode/16. 3Sum Closest/3SumClosest.py
new file mode 100644
index 00000000..e0e836de
--- /dev/null
+++ b/Algorithm/TwoPointers/leetcode/16. 3Sum Closest/3SumClosest.py	
@@ -0,0 +1,119 @@
+# 以下は、**3Sum Closest問題**のPython実装です。
+
+# LeetCode形式（`class Solution`）に準拠し、
+# **型指定・時間計算量・メモリ使用量**を明示しています。
+
+# ---
+
+# ## **コード（Python）**
+
+# ```python
+from typing import List
+
+class Solution:
+    def threeSumClosest(self, nums: List[int], target: int) -> int:
+        """
+        3Sum Closest 問題の解法
+
+        Parameters:
+        nums (List[int]): 入力配列（整数リスト）
+        target (int): 目標値
+
+        Returns:
+        int: 3つの数の和の中で、target に最も近いもの
+
+        時間計算量: O(n^2)
+        メモリ使用量: O(1)（ソート時のスタックを除く）
+        """
+
+        nums.sort()  # ソート（O(n log n)）
+
+        n: int = len(nums)
+        # 初期値設定
+        closest_sum: int = nums[0] + nums[1] + nums[2]
+        min_diff: int = abs(closest_sum - target)
+
+        # メインループ（O(n^2)）
+        for i in range(n - 2):
+            left: int = i + 1
+            right: int = n - 1
+
+            while left < right:
+                current_sum: int = nums[i] + nums[left] + nums[right]
+                current_diff: int = abs(current_sum - target)
+
+                # 最小差を更新
+                if current_diff < min_diff:
+                    min_diff = current_diff
+                    closest_sum = current_sum
+
+                # 目標値と一致した場合、即返却（最適解）
+                if current_sum == target:
+                    return current_sum
+                elif current_sum < target:
+                    left += 1
+                else:
+                    right -= 1
+
+        return closest_sum
+
+# ## **テストケース**
+
+# ```python
+# if __name__ == "__main__":
+#     solver = Solution()
+#     print(solver.threeSumClosest([-1, 2, 1, -4], 1))  # 出力: 2
+#     print(solver.threeSumClosest([0, 0, 0], 1))       # 出力: 0
+# ```
+
+# ---
+
+# ## **処理の詳細**
+
+# | 処理       | 時間計算量      | メモリ          |
+# | -------- | ---------- | ------------ |
+# | ソート      | O(n log n) | O(1)（インプレース） |
+# | 2ポインター探索 | O(n²)      | O(1)         |
+# | **全体**   | O(n²)      | O(1)         |
+
+# ---
+
+# ## **図解（簡易）**
+
+# ### 例: `nums = [-1, 2, 1, -4], target = 1`
+
+# 1. **ソート**
+
+# ```
+# [-4, -1, 1, 2]
+# ```
+
+# 2. **探索**
+
+# | i  | left | right | 合計 | 差      |
+# | -- | ---- | ----- | -- | ------ |
+# | -4 | -1   | 2     | -3 | 4      |
+# | -4 | 1    | 2     | -1 | 2      |
+# | -1 | 1    | 2     | 2  | 1 (最小) |
+
+# ---
+
+# ## **メモリと実行時間について**
+
+# * **メモリ**：
+
+#   * ソートはPythonの`Timsort`（O(log n)の再帰スタック使用）
+#   * 基本的に**定数メモリ O(1)**（配列はインプレース）
+
+# * **実行時間の目安**：
+
+#   * n=500の場合：最大約12万回ループ（実行時間は数十ms程度）
+
+# ---
+
+# ## **まとめ**
+
+# * **時間計算量**：O(n²)
+# * **メモリ**：O(1)
+# * **LeetCode対応（class Solution）**
+# * **CPython 3.11.4で動作確認済**
diff --git a/Algorithm/TwoPointers/leetcode/16. 3Sum Closest/3SumClosest.ts b/Algorithm/TwoPointers/leetcode/16. 3Sum Closest/3SumClosest.ts
new file mode 100644
index 00000000..e4855ebe
--- /dev/null
+++ b/Algorithm/TwoPointers/leetcode/16. 3Sum Closest/3SumClosest.ts	
@@ -0,0 +1,96 @@
+// エラーの原因は以下です：
+
+// ```
+// Cannot find name 'threeSumClosest'
+// ```
+
+// ### 理由：
+
+// `threeSumClosest`は `Solution` クラスの**インスタンスメソッド**として定義していますが、
+// 呼び出し側で `threeSumClosest()` を直接呼んでいると発生するエラーです。
+
+// TypeScriptでは**インスタンス生成後に `this.method()` として呼ぶ必要があります。**
+
+// ---
+
+// ## **正しい呼び出し方**
+
+// ```typescript
+// const solver = new Solution();
+// console.log(solver.threeSumClosest([-1, 2, 1, -4], 1));  // 出力: 2
+// console.log(solver.threeSumClosest([0, 0, 0], 1));       // 出力: 0
+// ```
+
+// ---
+
+// ## **LeetCode向け解答（クラスを使わない形式）**
+
+// LeetCode用の提出では、`class Solution` が既に与えられているか、関数単体での提出が求められます。
+
+// 以下は、**関数だけの形式**：
+
+// ```typescript
+/**
+ * 3Sum Closest 問題の解法
+ * @param nums - 入力配列（整数）
+ * @param target - 目標値（整数）
+ * @returns 最もtargetに近い3つの数の合計（整数）
+ * 
+ * 時間計算量: O(n^2)
+ * メモリ使用量: O(1)（ソート時のスタックを除く）
+ */
+function threeSumClosest(nums: number[], target: number): number {
+    const n: number = nums.length;
+    nums.sort((a, b) => a - b);
+
+    let closestSum: number = nums[0] + nums[1] + nums[2];
+    let minDiff: number = Math.abs(closestSum - target);
+
+    for (let i = 0; i < n - 2; i++) {
+        let left: number = i + 1;
+        let right: number = n - 1;
+
+        while (left < right) {
+            const currentSum: number = nums[i] + nums[left] + nums[right];
+            const currentDiff: number = Math.abs(currentSum - target);
+
+            if (currentDiff < minDiff) {
+                minDiff = currentDiff;
+                closestSum = currentSum;
+            }
+
+            if (currentSum === target) {
+                return currentSum;
+            } else if (currentSum < target) {
+                left++;
+            } else {
+                right--;
+            }
+        }
+    }
+
+    return closestSum;
+}
+// ```
+
+// ---
+
+// ## **テストコード**
+
+// ```typescript
+// console.log(threeSumClosest([-1, 2, 1, -4], 1));  // 出力: 2
+// console.log(threeSumClosest([0, 0, 0], 1));       // 出力: 0
+// ```
+
+// ---
+
+// ## **まとめ**
+
+// | 利用環境         | 使い方                                           |
+// | ------------ | --------------------------------------------- |
+// | **LeetCode** | 関数だけ提出（上記形式）                                  |
+// | **ローカル実行**   | クラス形式でもOK（`new Solution().threeSumClosest()`） |
+
+// どちらの形式でも対応可能ですが、LeetCode用なら**関数形式の方が安全**です。
+
+// もし、**クラス形式での提出例**も必要でしたらお伝えください！
diff --git a/Algorithm/TwoPointers/leetcode/16. 3Sum Closest/README.md b/Algorithm/TwoPointers/leetcode/16. 3Sum Closest/README.md
new file mode 100644
index 00000000..e97a6def
--- /dev/null
+++ b/Algorithm/TwoPointers/leetcode/16. 3Sum Closest/README.md	
@@ -0,0 +1,195 @@
+
+---
+
+## **問題のおさらい**
+
+### 入力：
+
+```text
+nums = [-1, 2, 1, -4]
+target = 1
+```
+
+### 出力：
+
+```text
+2
+```
+
+---
+
+## **アルゴリズムの流れ（図解）**
+
+### **Step1: ソート**
+
+```text
+元の配列: [-1, 2, 1, -4]
+ソート後: [-4, -1, 1, 2]
+```
+
+**目的：**
+
+* ソートしておくことで、\*\*2ポインター法（leftとrightを動かす）\*\*が使える
+
+---
+
+### **Step2: メインループ**
+
+#### 概要：
+
+* `i`を固定し、残りの`2つの数字`は**2ポインター法**で探索
+
+---
+
+## **図解で解説**
+
+### **初期設定**
+
+| インデックス | 値  |
+| :----: | -- |
+|    i   | -4 |
+|  left  | -1 |
+|  right | 2  |
+
+---
+
+### **Iteration 1**
+
+#### i = 0（nums\[i] = -4）
+
+**初期状態：**
+
+```
+[-4] [-1] [1] [2]
+   ↑    ↑      ↑
+   i   left   right
+```
+
+#### 1回目計算：
+
+```
+sum = -4 + (-1) + 2 = -3
+diff = |1 - (-3)| = 4
+```
+
+最小差が更新される → `closestSum = -3`
+
+---
+
+#### leftポインターを右に移動（1に）
+
+```
+[-4] [-1] [1] [2]
+   ↑         ↑ ↑
+   i       left right
+```
+
+#### 2回目計算：
+
+```
+sum = -4 + 1 + 2 = -1
+diff = |1 - (-1)| = 2
+```
+
+最小差が更新される → `closestSum = -1`
+
+---
+
+#### left移動（left=3、right=3なので終了）
+
+---
+
+### **Iteration 2**
+
+#### i = 1（nums\[i] = -1）
+
+初期状態：
+
+```
+[-4] [-1] [1] [2]
+         ↑   ↑   ↑
+         i  left right
+```
+
+---
+
+#### 1回目計算：
+
+```
+sum = -1 + 1 + 2 = 2
+diff = |1 - 2| = 1
+```
+
+最小差が更新される → `closestSum = 2`
+
+---
+
+#### rightポインターを左に移動（right=1、終了）
+
+---
+
+### **探索終了**
+
+最終的な結果：
+
+```
+closestSum = 2
+```
+
+---
+
+## **全体イメージ**
+
+```
+ソート → [-4, -1, 1, 2]
+
+i=-4の場合：
+   [-4] [-1] [1] [2]
+      ↑    ↑     ↑
+      i   left  right
+  -3, -1 が候補
+
+i=-1の場合：
+   [-4] [-1] [1] [2]
+           ↑   ↑   ↑
+           i  left right
+  2 が候補（最も近い）
+```
+
+---
+
+## **解析まとめ**
+
+| 処理内容   | 詳細             | 時間計算量      |
+| ------ | -------------- | ---------- |
+| ソート    | `nums.sort()`  | O(n log n) |
+| メインループ | `i`固定＋2ポインター探索 | O(n²)      |
+| メモリ    | 追加配列なし、O(1)    |            |
+
+---
+
+## **時間計算量**
+
+| 処理     | 計算量        |
+| ------ | ---------- |
+| ソート    | O(n log n) |
+| 2重ループ  | O(n²)      |
+| **合計** | O(n²)      |
+
+---
+
+## **メモリ使用量**
+
+| 項目     | メモリ            |
+| ------ | -------------- |
+| 入力配列   | O(n)（既存配列のみ）   |
+| 補助変数   | O(1)           |
+| **合計** | O(1)（追加メモリは定数） |
+
+---
+
+## **まとめ**
+
+* **ソート+2ポインター法**で高速化（O(n²)）
+* **直感的な探索**でシンプルかつ実用的
+* 最大500要素でも問題なく動作（LeetCode制限内）