diff --git a/Algorithm/DynamicProgramming/leetcode/10. Regular Expression Matching/README.md b/Algorithm/DynamicProgramming/leetcode/10. Regular Expression Matching/README.md
new file mode 100644
index 00000000..a49ed49c
--- /dev/null
+++ b/Algorithm/DynamicProgramming/leetcode/10. Regular Expression Matching/README.md	
@@ -0,0 +1,182 @@
+ **JavaScript + DP解法** を用いて処理し、**各処理を図を使って具体的に説明**します。
+
+---
+
+## 🎯 問題概要（再掲）
+
+* `s`：マッチさせたい文字列（例: `"aa"`）
+* `p`：正規表現パターン（例: `"a*"`）
+
+**正規表現ルール**：
+
+| 記号  | 意味                |
+| --- | ----------------- |
+| `.` | 任意の1文字にマッチ        |
+| `*` | 直前の文字の 0 回以上の繰り返し |
+
+---
+
+## 🧠 解法方針：動的計画法（DP）
+
+### 🧩 状態定義
+
+* `dp[i][j] = true`
+  ⇔ `s[0..i-1]`（長さ i の prefix）と `p[0..j-1]`（長さ j の prefix）がマッチする
+
+---
+
+## 🧮 例：`s = "aa"`、`p = "a*"`
+
+### 初期状態
+
+```
+s = " a  a"
+     ↑  ↑
+i=  1  2
+
+p = " a  *"
+     ↑  ↑
+j=  1  2
+```
+
+### DP テーブルの初期化
+
+|    | "" | a | \* |
+| -- | -- | - | -- |
+| "" | T  | F | T  |
+| a  | F  | T | T  |
+| a  | F  | F | T  |
+
+---
+
+### 📊 ステップ 1：`dp[0][0] = true`
+
+空文字列同士は常にマッチ。
+
+```
+dp[0][0] = true
+```
+
+---
+
+### 📊 ステップ 2：パターンに `*` がある場合の初期化
+
+* `dp[0][2] = dp[0][0] = true`（`a*` が空文字列にマッチ）
+
+```
+Pattern: "a*"
+→ '*' は前の 'a' を0回とみなせるのでOK
+```
+
+---
+
+### 📊 ステップ 3：DPテーブルの構築（再帰的に状態更新）
+
+```js
+for (let i = 1; i <= m; i++) {
+  for (let j = 1; j <= n; j++) {
+    ...
+  }
+}
+```
+
+### 更新規則（図示）
+
+#### 🔹 case1: 文字一致 or `.`（1文字マッチ）
+
+```
+if (p[j-1] === s[i-1] || p[j-1] === '.')
+→ dp[i][j] = dp[i-1][j-1]
+```
+
+```
+s: ... a
+p: ... a
+     ↑   ↑
+     i   j
+```
+
+---
+
+#### 🔹 case2: `*` の場合（0回 or 1回以上）
+
+```
+if (p[j-1] === '*') {
+    dp[i][j] = dp[i][j-2]   // * を0回使用
+    if (p[j-2] === s[i-1] || p[j-2] === '.')
+        dp[i][j] |= dp[i-1][j] // * を1回以上使用
+}
+```
+
+```
+Pattern:  a*
+          ↑↑
+          j-2 j-1
+
+s:     a   a
+       ↑
+       i-1
+```
+
+---
+
+## ✅ 最終的なDPテーブル（例：s="aa", p="a\*"）
+
+|    | "" | a | \* |
+| -- | -- | - | -- |
+| "" | ✅  | ❌ | ✅  |
+| a  | ❌  | ✅ | ✅  |
+| a  | ❌  | ❌ | ✅  |
+
+→ `dp[2][2] = true`（完全一致）
+
+---
+
+## 🖼️ 図による処理まとめ
+
+```
+s = "aa"
+p = "a*"
+
+1. dp[0][0] = true          // 空文字列同士マッチ
+
+2. dp[0][2] = true          // a* → *は0回で空文字にマッチ
+
+3. dp[1][1] = true          // s[0] = a, p[0] = a
+
+4. dp[1][2] = true          // '*' で1回以上の a
+
+5. dp[2][2] = true          // '*' でさらに1回
+```
+
+---
+
+## 📌 結果
+
+```js
+console.log(dp[s.length][p.length]); // true
+```
+
+---
+
+## 🔁 応用例
+
+### s = "ab", p = ".\*"
+
+* `.` → 任意の文字
+* `*` → 何回でも繰り返し → すべての文字列にマッチ
+
+```
+dp[2][2] = true
+```
+
+---
+
+## 🧠 メモリ＆計算量
+
+* 時間：O(m × n)
+* 空間：O(m × n)
+
+  * 制約が 20 以下なので問題なし（最大 400 要素）
+
+---
diff --git a/Algorithm/DynamicProgramming/leetcode/10. Regular Expression Matching/RegularExpressionMatching.py b/Algorithm/DynamicProgramming/leetcode/10. Regular Expression Matching/RegularExpressionMatching.py
new file mode 100644
index 00000000..70aec0c6
--- /dev/null
+++ b/Algorithm/DynamicProgramming/leetcode/10. Regular Expression Matching/RegularExpressionMatching.py	
@@ -0,0 +1,81 @@
+# 以下は、LeetCodeの「正規表現マッチング」問題に対する **Python（CPython 3.11.4対応）** の解答です。
+# **型アノテーション付き**で記述し、**計算量**と**メモリ使用**にも配慮しています。
+
+# ## ✅ 問題概要（再掲）
+
+# * `.` は任意の1文字
+# * `*` は直前の文字の 0 回以上の繰り返し
+# * `s` 全体と `p` 全体がマッチするかを判定
+
+# ---
+
+# ## 🧠 解法方針：動的計画法（DP）
+
+# * 状態：`dp[i][j]` ⇒ `s[:i]` と `p[:j]` がマッチするか
+# * 遷移：
+
+#   * `p[j - 1] == '*'`：
+
+#     * `dp[i][j] = dp[i][j - 2] or (dp[i - 1][j] if p[j - 2] matches s[i - 1])`
+#   * それ以外：
+
+#     * `dp[i][j] = dp[i - 1][j - 1]` if `p[j - 1] == s[i - 1]` or `p[j - 1] == '.'`
+
+# ## 🐍 Python実装（型付き）
+
+from typing import List
+
+class Solution:
+    def isMatch(self, s: str, p: str) -> bool:
+        m: int = len(s)
+        n: int = len(p)
+
+        # dp[i][j] := s[:i] と p[:j] がマッチするか
+        dp: List[List[bool]] = [[False] * (n + 1) for _ in range(m + 1)]
+        dp[0][0] = True  # 空文字同士はマッチ
+
+        # パターン初期化（空文字にマッチする * の処理）
+        for j in range(2, n + 1):
+            if p[j - 1] == '*':
+                dp[0][j] = dp[0][j - 2]
+
+        # DP更新
+        for i in range(1, m + 1):
+            for j in range(1, n + 1):
+                if p[j - 1] == '.' or p[j - 1] == s[i - 1]:
+                    dp[i][j] = dp[i - 1][j - 1]
+                elif p[j - 1] == '*':
+                    dp[i][j] = dp[i][j - 2]  # * を 0 回使う
+                    if p[j - 2] == '.' or p[j - 2] == s[i - 1]:
+                        dp[i][j] |= dp[i - 1][j]  # * を 1 回以上使う
+
+        return dp[m][n]
+    
+# ## 🔎 使用例
+
+# ```python
+# if __name__ == "__main__":
+#     sol = Solution()
+#     print(sol.isMatch("aa", "a"))    # False
+#     print(sol.isMatch("aa", "a*"))   # True
+#     print(sol.isMatch("ab", ".*"))   # True
+# ```
+
+# ---
+
+# ## ⏱ 計算量・メモリ消費
+
+# | 項目        | 値                       |
+# | --------- | ----------------------- |
+# | 時間計算量     | O(m × n)                |
+# | 空間計算量     | O(m × n)                |
+# | 入力サイズ最大   | 20文字（s, p）              |
+# | 最大DP表サイズ  | 21 × 21 = 441セル         |
+# | メモリ消費（概算） | 約 441 × 1バイト ≈ **500B** |
+
+# ## ✅ 補足：なぜDPか？
+
+# * 再帰+メモ化でも解けるが、LeetCodeではTLEになりやすい。
+# * 全探索で部分一致を記録できるDPが最も安定した手法。
+
+# ご希望があれば、再帰＋メモ化（`lru_cache`）版や、図解を含めたステップバイステップ解析も可能です。
diff --git a/Algorithm/DynamicProgramming/leetcode/10. Regular Expression Matching/RegularExpressionMatching.ts b/Algorithm/DynamicProgramming/leetcode/10. Regular Expression Matching/RegularExpressionMatching.ts
new file mode 100644
index 00000000..ad02b29d
--- /dev/null
+++ b/Algorithm/DynamicProgramming/leetcode/10. Regular Expression Matching/RegularExpressionMatching.ts	
@@ -0,0 +1,94 @@
+// 以下は、LeetCodeの正規表現マッチング問題に対する **JavaScript（Node.js）での解答例** です。`fs` モジュールを用いて標準入力から `s` と `p` を受け取り、動的計画法（DP）で `.` や `*` を考慮した完全一致の判定を行います。
+
+// ---
+
+// ### ✅ 解法方針（動的計画法・2次元DP）
+
+// * `dp[i][j]`：`s[0..i-1]` と `p[0..j-1]` がマッチするかを表す。
+// * 状態遷移：
+
+//   * `p[j - 1] === '*'` の場合：
+
+//     * 無視：`dp[i][j] = dp[i][j - 2]`
+//     * 一致していて繰り返し使用：`dp[i][j] |= dp[i - 1][j]`
+//   * `p[j - 1] === s[i - 1] || p[j - 1] === '.'` の場合：
+
+//     * `dp[i][j] = dp[i - 1][j - 1]`
+
+// ---
+
+// ### 📦 JavaScript（Node.js）実装（`fs` 使用）
+
+// ```javascript
+const fs = require('fs');
+
+// 入力読み込み
+const input = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n');
+const s = input[0];  // 入力文字列 s
+const p = input[1];  // パターン文字列 p
+
+function isMatch(s, p) {
+    const m = s.length;
+    const n = p.length;
+
+    // 初期化：false埋め、dp[0][0] = true（空文字同士は一致）
+    const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(false));
+    dp[0][0] = true;
+
+    // 空文字列 s に対するパターン p の初期化（例: a*, a*b*, a*b*c*）
+    for (let j = 2; j <= n; j++) {
+        if (p[j - 1] === '*') {
+            dp[0][j] = dp[0][j - 2];
+        }
+    }
+
+    // DPテーブル更新
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            if (p[j - 1] === '.' || p[j - 1] === s[i - 1]) {
+                dp[i][j] = dp[i - 1][j - 1];
+            } else if (p[j - 1] === '*') {
+                dp[i][j] = dp[i][j - 2]; // * を0回使用
+                if (p[j - 2] === '.' || p[j - 2] === s[i - 1]) {
+                    dp[i][j] = dp[i][j] || dp[i - 1][j]; // * を1回以上使用
+                }
+            }
+        }
+    }
+
+    return dp[m][n];
+}
+
+// 出力
+console.log(isMatch(s, p));
+
+// ### 🧪 入力方法（例）
+
+// 以下のような入力ファイルまたは標準入力で動作します：
+
+// ```
+// aa
+// a*
+// ```
+
+// 出力：
+
+// ```
+// true
+// ```
+
+// ---
+
+// ### ⏱ 性能（最悪計算量）
+
+// * 時間計算量：O(m × n)
+// * 空間計算量：O(m × n)
+// * 制約が小さい（s, p ≤ 20）ので高速かつメモリ効率良好です。
+
+// ---
+
+// 必要であれば、標準入力ファイルを指定してテスト可能です。Node.js環境で実行する場合：
+
+// ```bash
+// echo -e "ab\n.*" | node solution.js
+// ```
\ No newline at end of file
diff --git a/Algorithm/Meet-in-the-middle/atcoder/B14/B14.go b/Algorithm/Meet-in-the-middle/atcoder/B14/B14.go
new file mode 100644
index 00000000..b6caca53
--- /dev/null
+++ b/Algorithm/Meet-in-the-middle/atcoder/B14/B14.go
@@ -0,0 +1,123 @@
+// 以下に、**Go (go 1.20.6)** による解答を提示します。
+// 制約に対応するために、**半分全列挙（Meet-in-the-middle）** を用いた効率的な実装です。
+// 型を明示し、処理時間・メモリ使用量を考慮しています。
+
+// ## ✅ 解法概要
+
+// * 与えられた整数列を **前半・後半に分割**
+// * 各部分の **部分集合和を全列挙**（最大 2^15 = 32,768 通り）
+// * 一方の部分和リストに対して **二分探索**を使用し、合計が `K` になる組を探索
+
+// ## ✅ Go実装（Go 1.20.6）
+
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+// getSubsetSums returns all possible subset sums of arr.
+func getSubsetSums(arr []int) []int {
+	n := len(arr)
+	res := make([]int, 0, 1<<n)
+	for bit := 0; bit < (1 << n); bit++ {
+		sum := 0
+		for i := 0; i < n; i++ {
+			if bit&(1<<i) != 0 {
+				sum += arr[i]
+			}
+		}
+		res = append(res, sum)
+	}
+	return res
+}
+
+// binarySearch checks if target exists in sorted slice arr.
+func binarySearch(arr []int, target int) bool {
+	left, right := 0, len(arr)-1
+	for left <= right {
+		mid := (left + right) / 2
+		if arr[mid] == target {
+			return true
+		} else if arr[mid] < target {
+			left = mid + 1
+		} else {
+			right = mid - 1
+		}
+	}
+	return false
+}
+
+func main() {
+	scanner := bufio.NewScanner(os.Stdin)
+	scanner.Scan()
+	header := strings.Fields(scanner.Text())
+	N, _ := strconv.Atoi(header[0])
+	K, _ := strconv.Atoi(header[1])
+
+	scanner.Scan()
+	fields := strings.Fields(scanner.Text())
+	A := make([]int, N)
+	for i := 0; i < N; i++ {
+		A[i], _ = strconv.Atoi(fields[i])
+	}
+
+	mid := N / 2
+	left := A[:mid]
+	right := A[mid:]
+
+	leftSums := getSubsetSums(left)
+	rightSums := getSubsetSums(right)
+	sort.Ints(rightSums)
+
+	for _, x := range leftSums {
+		remain := K - x
+		if binarySearch(rightSums, remain) {
+			fmt.Println("Yes")
+			return
+		}
+	}
+	fmt.Println("No")
+}
+
+// ## ✅ 入力例
+
+// ```
+// 6 30
+// 5 1 18 7 2 9
+// ```
+
+// ## ✅ 出力例
+
+// ```
+// Yes
+// ```
+
+// ---
+
+// ## ✅ 処理時間・空間計算量
+
+// | ステップ       | 計算量（最悪）                  |
+// | ---------- | ------------------------ |
+// | 部分和全列挙     | $O(2^{15} \cdot N)$      |
+// | ソート        | $O(2^{15} \log 2^{15})$  |
+// | 二分探索 × ループ | $O(2^{15} \log 2^{15})$  |
+// | 合計         | 約 **30万回程度の演算** → 1秒以内 ✅ |
+
+// * メモリ使用量：
+
+//   * `leftSums` + `rightSums`：最大 32,768 × 2 ≒ **65,000 整数** → 約 **260KB**程度
+//   * 上限（1024 MiB）に**大きく余裕あり**
+
+// ---
+
+// ## ✅ 特記事項（Go 1.20.6対応）
+
+// * `bufio.Scanner` により高速な入力処理
+// * 型安全：明示的な `int` スライス使用
+// * 標準ライブラリのみ使用（外部依存なし）
diff --git a/Algorithm/Meet-in-the-middle/atcoder/B14/B14.js b/Algorithm/Meet-in-the-middle/atcoder/B14/B14.js
new file mode 100644
index 00000000..c1fa8547
--- /dev/null
+++ b/Algorithm/Meet-in-the-middle/atcoder/B14/B14.js
@@ -0,0 +1,90 @@
+
+// * **制約**より `N ≤ 30` なので、**半分全列挙（Meet-in-the-middle）** を使って効率的に解を導きます。
+// * 入力は `fs.readFileSync` を使って取得します。
+// * 出力は `console.log` で行います。
+
+// ---
+
+// ### ✅ 解法：半分全列挙（Meet-in-the-middle）
+
+// * 配列を2つに分割して、各部分集合和を列挙し、片方はソート・二分探索。
+
+// ---
+
+// ### ✅ コード
+
+const fs = require('fs');
+
+function getSubsetSums(arr) {
+  const result = [];
+  const n = arr.length;
+  for (let bit = 0; bit < (1 << n); bit++) {
+    let sum = 0;
+    for (let i = 0; i < n; i++) {
+      if (bit & (1 << i)) sum += arr[i];
+    }
+    result.push(sum);
+  }
+  return result;
+}
+
+function binarySearch(arr, target) {
+  let left = 0, right = arr.length - 1;
+  while (left <= right) {
+    const mid = (left + right) >> 1;
+    if (arr[mid] === target) return true;
+    if (arr[mid] < target) left = mid + 1;
+    else right = mid - 1;
+  }
+  return false;
+}
+
+function main() {
+  const input = fs.readFileSync('/dev/stdin', 'utf8').trim().split(/\s+/).map(Number);
+  const N = input[0];
+  const K = input[1];
+  const A = input.slice(2);
+
+  const mid = Math.floor(N / 2);
+  const left = A.slice(0, mid);
+  const right = A.slice(mid);
+
+  const leftSums = getSubsetSums(left);
+  const rightSums = getSubsetSums(right);
+  rightSums.sort((a, b) => a - b);
+
+  for (const x of leftSums) {
+    const remain = K - x;
+    if (binarySearch(rightSums, remain)) {
+      console.log("Yes");
+      return;
+    }
+  }
+
+  console.log("No");
+}
+
+main();
+
+// ### ✅ 実行例
+
+// 入力:
+
+// ```
+// 6 30
+// 5 1 18 7 2 9
+// ```
+
+// 出力:
+
+// ```
+// Yes
+// ```
+
+// ---
+
+// ### ✅ 時間・空間計算量
+
+// * 時間: `O(2^(N/2) * log(2^(N/2)))` ≒ `2^15 * 15` → 高速（制限内）
+// * 空間: `O(2^(N/2))` → 最大 32,768 個（メモリ制限内）
+
diff --git a/Algorithm/Meet-in-the-middle/atcoder/B14/B14.php b/Algorithm/Meet-in-the-middle/atcoder/B14/B14.php
new file mode 100644
index 00000000..25dd8ca5
--- /dev/null
+++ b/Algorithm/Meet-in-the-middle/atcoder/B14/B14.php
@@ -0,0 +1,110 @@
+<!-- 以下に、**PHP 8.2.8** に対応した解答を提示します。
+この解法は、**半分全列挙（Meet-in-the-middle）** を用いて、時間・メモリ制約の範囲で最適に動作します。
+
+## ✅ 解法戦略（再掲）
+
+* 配列を2分割して、それぞれの部分集合和を列挙（最大 $2^{15} = 32,768$ 通り）
+* 一方をソートし、もう一方の要素と合わせて **二分探索**で目的の値 `K` を探索
+
+
+## ✅ PHPコード（PHP 8.2.8対応・型付き風コメント付き）
+<?php
+declare(strict_types=1);
+
+/**
+ * @param array<int> $arr
+ * @return array<int>
+ */
+function getSubsetSums(array $arr): array {
+    $n = count($arr);
+    $res = [];
+    for ($bit = 0; $bit < (1 << $n); $bit++) {
+        $sum = 0;
+        for ($i = 0; $i < $n; $i++) {
+            if ($bit & (1 << $i)) {
+                $sum += $arr[$i];
+            }
+        }
+        $res[] = $sum;
+    }
+    return $res;
+}
+
+/**
+ * @param array<int> $arr
+ * @param int $target
+ * @return bool
+ */
+function binarySearch(array $arr, int $target): bool {
+    $left = 0;
+    $right = count($arr) - 1;
+    while ($left <= $right) {
+        $mid = intdiv($left + $right, 2);
+        if ($arr[$mid] === $target) {
+            return true;
+        } elseif ($arr[$mid] < $target) {
+            $left = $mid + 1;
+        } else {
+            $right = $mid - 1;
+        }
+    }
+    return false;
+}
+
+function main(): void {
+    $input = trim(file_get_contents('php://stdin'));
+    $tokens = array_map('intval', preg_split('/\s+/', $input));
+    
+    $N = $tokens[0];
+    $K = $tokens[1];
+    $A = array_slice($tokens, 2);
+    
+    $mid = intdiv($N, 2);
+    $left = array_slice($A, 0, $mid);
+    $right = array_slice($A, $mid);
+
+    $leftSums = getSubsetSums($left);
+    $rightSums = getSubsetSums($right);
+    sort($rightSums);
+
+    foreach ($leftSums as $x) {
+        $remain = $K - $x;
+        if (binarySearch($rightSums, $remain)) {
+            echo "Yes\n";
+            return;
+        }
+    }
+    echo "No\n";
+}
+
+main();
+
+// ## ✅ 入力例
+
+// ```
+// 6 30
+// 5 1 18 7 2 9
+// ```
+
+// ## ✅ 出力例
+
+// ```
+// Yes
+// ```
+
+// ## ✅ 時間・空間計算量
+
+// | 処理       | 計算量                       |
+// | -------- | ------------------------- |
+// | 部分集合和列挙  | $O(2^{N/2} \cdot N)$      |
+// | ソート      | $O(2^{N/2} \log 2^{N/2})$ |
+// | 探索（×ループ） | $O(2^{N/2} \log 2^{N/2})$ |
+// | **合計**   | 約 30 万回程度の計算 → 1秒以内OK     |
+
+// * 最大メモリ使用：配列2個 × $2^{15} \approx 32,768$ 要素 → **数百KB** → **1024 MiB制限に収まる**
+
+// ## ✅ 注意点（PHP固有）
+
+// * PHP はデフォルトで大きな整数も扱える（int型は任意精度で扱える環境も多い）
+// * `declare(strict_types=1)` で型安全な動作を明示
+// * コメントで型注釈を明示（PHP 8.2 でも `array<int>` などの DocBlock を活用）
\ No newline at end of file
diff --git a/Algorithm/Meet-in-the-middle/atcoder/B14/B14.py b/Algorithm/Meet-in-the-middle/atcoder/B14/B14.py
new file mode 100644
index 00000000..ad411949
--- /dev/null
+++ b/Algorithm/Meet-in-the-middle/atcoder/B14/B14.py
@@ -0,0 +1,93 @@
+# 以下は、**Python (CPython 3.11.4)** を用いて、**半分全列挙（Meet-in-the-middle）** 手法で解く実装です。
+# 処理時間・メモリ消費を考慮して、最大 $N = 30$ にも対応可能です。
+
+# ## ✅ 解法概要
+
+# * 配列を **2つに分割**（最大15要素ずつ）
+# * 各部分集合の和を列挙（`2^15 = 32,768` 通り）
+# * **二分探索**により、合計がちょうど `K` になるか確認
+
+# ## ✅ 実装（Python 3.11.4・型付き）
+
+from typing import List
+import sys
+import bisect
+
+def get_subset_sums(arr: List[int]) -> List[int]:
+    n: int = len(arr)
+    result: List[int] = []
+    for bit in range(1 << n):
+        total: int = 0
+        for i in range(n):
+            if bit & (1 << i):
+                total += arr[i]
+        result.append(total)
+    return result
+
+def main() -> None:
+    input = sys.stdin.read
+    data = list(map(int, input().split()))
+    
+    N: int = data[0]
+    K: int = data[1]
+    A: List[int] = data[2:]
+    
+    mid: int = N // 2
+    left: List[int] = A[:mid]
+    right: List[int] = A[mid:]
+    
+    left_sums: List[int] = get_subset_sums(left)
+    right_sums: List[int] = get_subset_sums(right)
+    right_sums.sort()
+    
+    for x in left_sums:
+        remain: int = K - x
+        idx: int = bisect.bisect_left(right_sums, remain)
+        if idx < len(right_sums) and right_sums[idx] == remain:
+            print("Yes")
+            return
+    print("No")
+
+if __name__ == "__main__":
+    main()
+
+# ## ✅ 入出力例
+
+# ### 入力
+
+# ```
+# 6 30
+# 5 1 18 7 2 9
+# ```
+
+# ### 出力
+
+# ```
+# Yes
+# ```
+
+# ---
+
+# ## ✅ 時間計算量
+
+# | ステップ                  | 計算量                                             |
+# | --------------------- | ----------------------------------------------- |
+# | 部分集合和列挙 (`2^(N/2)`)   | $O(2^{N/2} \cdot N) \approx 500,000$（最大）        |
+# | ソート                   | $O(2^{N/2} \log 2^{N/2})$                       |
+# | 二分探索 × `left_sums` 件数 | $O(2^{N/2} \log 2^{N/2})$                       |
+# | **合計**                | $O(2^{N/2} \log 2^{N/2})$ ≒ $3 \times 10^5$（高速） |
+
+# ---
+
+# ## ✅ メモリ計算量
+
+# * 各部分和リスト：最大 $2^{15} = 32,768$ 要素 × 2つ ≒ 約 260 KB 程度
+# * 制限（1024 MiB）には **余裕で収まる**
+
+# ---
+
+# ## ✅ 備考
+
+# * `bisect.bisect_left` により、Python 標準ライブラリで高速な二分探索が可能
+# * 型アノテーションにより、静的型解析ツール（mypy等）にも対応
+
diff --git a/Algorithm/Meet-in-the-middle/atcoder/B14/B14.ts b/Algorithm/Meet-in-the-middle/atcoder/B14/B14.ts
new file mode 100644
index 00000000..cc921c97
--- /dev/null
+++ b/Algorithm/Meet-in-the-middle/atcoder/B14/B14.ts
@@ -0,0 +1,100 @@
+// 以下に、**TypeScript 5.1 + Node.js 18.16.1** で動作する完全な解法を提示します。
+
+// * 半分全列挙（**Meet-in-the-middle**）を使って高速化
+// * 入力は `fs` モジュールを使って `/dev/stdin` から読み取ります
+
+// ## ✅ TypeScript 解法コード
+
+import * as fs from 'fs';
+
+function getSubsetSums(arr: number[]): number[] {
+  const result: number[] = [];
+  const n: number = arr.length;
+  for (let bit = 0; bit < (1 << n); bit++) {
+    let sum = 0;
+    for (let i = 0; i < n; i++) {
+      if (bit & (1 << i)) sum += arr[i];
+    }
+    result.push(sum);
+  }
+  return result;
+}
+
+function binarySearch(arr: number[], target: number): boolean {
+  let left = 0, right = arr.length - 1;
+  while (left <= right) {
+    const mid = (left + right) >> 1;
+    if (arr[mid] === target) return true;
+    if (arr[mid] < target) left = mid + 1;
+    else right = mid - 1;
+  }
+  return false;
+}
+
+function main(): void {
+  const input: string = fs.readFileSync('/dev/stdin', 'utf8').trim();
+  const tokens: number[] = input.split(/\s+/).map(Number);
+  const N: number = tokens[0];
+  const K: number = tokens[1];
+  const A: number[] = tokens.slice(2);
+
+  const mid: number = Math.floor(N / 2);
+  const left: number[] = A.slice(0, mid);
+  const right: number[] = A.slice(mid);
+
+  const leftSums: number[] = getSubsetSums(left);
+  const rightSums: number[] = getSubsetSums(right);
+  rightSums.sort((a, b) => a - b);
+
+  for (const x of leftSums) {
+    const remain = K - x;
+    if (binarySearch(rightSums, remain)) {
+      console.log("Yes");
+      return;
+    }
+  }
+
+  console.log("No");
+}
+
+main();
+
+// ## ✅ 実行方法（ローカル環境）
+
+// ```bash
+// # 1. ファイル名を `main.ts` として保存
+// # 2. 実行（ts-node or tsc + node）
+// npx ts-node main.ts < input.txt
+
+// # または
+// tsc main.ts && node main.js < input.txt
+// ```
+
+// ---
+
+// ## ✅ 計算量と制限の確認
+
+// * 時間計算量：`O(2^(N/2) * log(2^(N/2)))` = 約 `3.3 * 10^5`（N=30） → **1秒以内に収まる**
+// * 空間計算量：最大 `2^15 ≒ 32,768` 要素 → **1024MB 制限内**
+// * 型安全：全て `number` 型で明示
+
+// ---
+
+// ## ✅ 入力例・出力例
+
+// ### 入力
+
+// ```
+// 6 30
+// 5 1 18 7 2 9
+// ```
+
+// ### 出力
+
+// ```
+// Yes
+// ```
+
+// ---
+
+// 必要であれば、ビジュアルな図解（例：部分和の生成方法）もご提供できます。
diff --git a/Algorithm/Meet-in-the-middle/atcoder/B14/README.md b/Algorithm/Meet-in-the-middle/atcoder/B14/README.md
new file mode 100644
index 00000000..acc0dc33
--- /dev/null
+++ b/Algorithm/Meet-in-the-middle/atcoder/B14/README.md
@@ -0,0 +1,308 @@
+今回の問題に対して使われた **半分全列挙（Meet-in-the-middle）** の手法について、**概念・手順・各処理の図解**を用いて丁寧に説明します。
+
+---
+
+## 🔷 半分全列挙（Meet-in-the-middle）とは？
+
+`N` がそこそこ大きく（例：N=30）の場合に、\*\*2ⁿ 全探索（部分集合全列挙）\*\*を直接行うと計算量が **2³⁰ ≒ 10⁹** になり、時間制限（1秒）内に終わりません。
+
+これを回避するために：
+
+### ✅ `N` 個の要素を **2つに分割**してそれぞれ `2^(N/2)` 通りだけ全列挙し、
+
+### ✅ それらの **和の組み合わせ** で目的の値 `K` を探索する手法です。
+
+---
+
+## 🔷 処理の全体フロー
+
+```txt
+入力: N=6, K=30, A = [5, 1, 18, 7, 2, 9]
+```
+
+```
+▼ Step 1: 配列を左右に分割
+      A = [5, 1, 18, 7, 2, 9]
+           ↑      ↑
+       left     right
+     [5, 1, 18] [7, 2, 9]
+```
+
+---
+
+## 🔷 Step 2: 各グループの部分和を列挙
+
+### 【左側3要素】の部分集合和（2^3 = 8通り）：
+
+```
+部分集合     和
+--------    ----
+{}           0
+{5}          5
+{1}          1
+{18}         18
+{5,1}        6
+{5,18}       23
+{1,18}       19
+{5,1,18}     24
+```
+
+→ **leftSums = \[0, 5, 1, 18, 6, 23, 19, 24]**
+
+### 【右側3要素】の部分集合和（2^3 = 8通り）：
+
+```
+部分集合     和
+--------    ----
+{}           0
+{7}          7
+{2}          2
+{9}          9
+{7,2}        9
+{7,9}        16
+{2,9}        11
+{7,2,9}      18
+```
+
+→ **rightSums = \[0, 7, 2, 9, 9, 16, 11, 18]**
+
+→ 重複を許して **ソート**：`[0, 2, 7, 9, 9, 11, 16, 18]`
+
+---
+
+## 🔷 Step 3: 片方（leftSums）を固定して、もう片方（rightSums）を **二分探索**
+
+例えば：
+
+```
+K = 30
+→ leftSum = 5 に対して、必要な rightSum = 25
+→ leftSum = 6 に対して、必要な rightSum = 24
+→ leftSum = 12 に対して、必要な rightSum = 18 ← 見つかった！
+```
+
+図解：
+
+```txt
+leftSum: 12     rightSums (sorted): [0, 2, 7, 9, 9, 11, 16, 18]
+                          ↑ found 30 - 12 = 18
+→ 合計 = 12 + 18 = 30 → 解あり
+```
+
+---
+
+## 🔷 Step 4: 解が見つかれば "Yes"、見つからなければ "No"
+
+---
+
+## 🔷 処理ごとの詳細と図解
+
+### 🔹 ① `getSubsetSums(arr: number[])` のイメージ
+
+全ての部分集合をビットで表して列挙します。
+
+#### 例: arr = \[5, 1, 18]
+
+```
+bit   subset     sum
+000 → {}          0
+001 → {5}         5
+010 → {1}         1
+011 → {5,1}       6
+100 → {18}       18
+101 → {5,18}     23
+110 → {1,18}     19
+111 → {5,1,18}   24
+```
+
+### 🔹 ② `binarySearch(arr, target)` のイメージ
+
+ソート済配列で二分探索します。
+
+```txt
+arr = [0, 2, 7, 9, 9, 11, 16, 18], target = 18
+
+→ 中央を探って左右に絞り込む
+→ 18 は見つかる → true を返す
+```
+
+---
+
+## 🔷 まとめ
+
+| ステップ | 処理                | 計算量               |
+| ---- | ----------------- | ----------------- |
+| 分割   | A を2つに分ける         | O(N)              |
+| 列挙   | 各部分集合和を計算（最大 2¹⁵） | O(2^(N/2) \* N)   |
+| ソート  | 右側の部分和をソート        | O(2^(N/2) \* log) |
+| 探索   | 左側からループ＆右側で二分探索   | O(2^(N/2) \* log) |
+
+→ **全体で O(2^(N/2) \* log(2^(N/2))) ≈ 3.3 × 10⁵** と高速！
+
+---
+
+## 🧠 この手法が有効な理由
+
+* N ≤ 30 のとき、2^30 = 10億 通り全探索は **間に合わない**
+* でも 2^15 = 約3万通りずつなら現実的 → **分割して合わせる！**
+
+---
+
+ここでは、コード内の各 `function` の**役割・内部処理・計算量**について詳しく解説し、特に `getSubsetSums` における **ビット操作による部分集合列挙の理由** を図解とともに明確に説明します。
+
+---
+
+## ✅ 各関数の詳細な解説
+
+---
+
+### ### ① `getSubsetSums(arr: number[]): number[]`
+
+#### ● 概要：
+
+* `arr` の全ての **部分集合の和** を列挙して返す。
+* 例: `arr = [a, b, c]` の場合、空集合から `{a,b,c}` まで、`2^n` 通りの和を求める。
+
+#### ● ビット全探索とは？
+
+* 長さ `n` の配列に対して、`0〜2^n-1` の整数を **ビット列** として見なすことで、各部分集合を表すことができます。
+
+#### 🔸 例： `arr = [5, 1, 18]` の場合
+
+| bit列  | 対応する集合     | 和  |
+| ----- | ---------- | -- |
+| `000` | `∅`        | 0  |
+| `001` | `{5}`      | 5  |
+| `010` | `{1}`      | 1  |
+| `011` | `{5,1}`    | 6  |
+| `100` | `{18}`     | 18 |
+| `101` | `{5,18}`   | 23 |
+| `110` | `{1,18}`   | 19 |
+| `111` | `{5,1,18}` | 24 |
+
+#### ● なぜビットで表現するのか？
+
+* 各要素を選ぶかどうかは **2択（選ぶ/選ばない）** → 2進数（bit）で自然に表現できる。
+* `bit & (1 << i)` によって、`i番目の要素を選ぶかどうか` を高速にチェックできる。
+
+#### ● 実装のポイント：
+
+```ts
+for (let bit = 0; bit < (1 << n); bit++) {
+  let sum = 0;
+  for (let i = 0; i < n; i++) {
+    if (bit & (1 << i)) {
+      sum += arr[i]; // i番目を選ぶ
+    }
+  }
+  result.push(sum);
+}
+```
+
+#### ● 計算量：
+
+* `2^n` 個の部分集合 → `O(2^n * n)` 時間（nは最大15なので余裕）
+
+---
+
+### ### ② `binarySearch(arr: number[], target: number): boolean`
+
+#### ● 概要：
+
+* ソート済み配列 `arr` に対して、値 `target` が存在するかを**二分探索**で確認。
+
+#### ● 処理の流れ：
+
+```ts
+while (left <= right) {
+  const mid = (left + right) >> 1;
+  if (arr[mid] === target) return true;
+  else if (arr[mid] < target) left = mid + 1;
+  else right = mid - 1;
+}
+```
+
+#### ● 特徴：
+
+* 時間計算量：`O(log N)` と高速。
+* 要素が昇順で整列されているため使用可能。
+
+#### ● 用途：
+
+* 左側の部分和 `x` に対して、`K - x` が右側に存在するかを確認するのに使用。
+
+---
+
+### ### ③ `main()`
+
+#### ● 概要：
+
+全体の制御を行う関数で、以下の手順を踏みます：
+
+1. 入力の読み取り・パース（`fs.readFileSync`）
+2. 配列 `A` を `left` と `right` に分割
+3. `getSubsetSums` によって各側の部分和を計算
+4. `rightSums` をソート（`binarySearch` 用）
+5. `leftSums` の各値 `x` に対し、`K - x` を `rightSums` に対して探索
+6. 合計 `K` が作れる組み合わせが見つかれば `"Yes"` を出力、なければ `"No"`
+
+#### ● 具体的な処理フロー図：
+
+```txt
+A = [5, 1, 18, 7, 2, 9], N=6, K=30
+
+     ┌────────────┐
+     │  input     │ ← fs.readFileSync
+     └────┬───────┘
+          ↓
+     ┌────────────┐
+     │  Split A   │ → left = [5,1,18], right = [7,2,9]
+     └────┬───────┘
+          ↓
+  ┌─────────────┐
+  │ getSubsetSums│ → leftSums（8個）, rightSums（8個）
+  └────┬────────┘
+       ↓
+  ┌───────────────┐
+  │ sort rightSums│ → binarySearch用
+  └────┬──────────┘
+       ↓
+  ┌─────────────────────────────┐
+  │ loop x in leftSums          │
+  │   → search K - x in rightSums│ ← binarySearch
+  └──────────┬──────────────────┘
+             ↓
+    Yes (found) / No (not found)
+```
+
+---
+
+## 🔶 `getSubsetSums` におけるビット列の利点まとめ
+
+| 項目     | 内容                                            |
+| ------ | --------------------------------------------- |
+| 簡潔性    | 全ての組み合わせを `0`〜`2ⁿ-1` の整数ループで1行で表現可能           |
+| 高速性    | ビット演算は整数演算なので非常に高速                            |
+| 実装の明快さ | `if (bit & (1 << i))` で「i番目の要素を使う」かどうかが一目で分かる |
+| 空間効率   | 明示的に配列を保持せずとも、部分集合をオンデマンドに計算できる               |
+| 応用性の広さ | 部分集合列挙、ナップサック問題、bitDP などの幅広いアルゴリズムに利用可能       |
+
+---
+
+## ✅ まとめ
+
+| 関数名             | 目的           | 時間計算量            | ポイント                   |
+| --------------- | ------------ | ---------------- | ---------------------- |
+| `getSubsetSums` | 配列の部分和を列挙    | `O(2^n * n)`     | **ビット全探索**を活用          |
+| `binarySearch`  | 値の探索（存在チェック） | `O(log n)`       | ソート済配列に高速探索            |
+| `main`          | 全体の制御ロジック    | `O(2^n * log n)` | Meet-in-the-middle の本体 |
+
+---
+
+| [提出日時](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-09 17:00:47 | [B14 - Another Subset Sum](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_cm) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [Go (go 1.20.6)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5002) | 1000 | 1407 Byte |  | 9 ms | 2112 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67446328) |
+| 2025-07-09 16:55:38 | [B14 - Another Subset Sum](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_cm) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [PHP (php 8.2.8)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5016) | 1000 | 1576 Byte |  | 35 ms | 23812 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67446181) |
+| 2025-07-09 16:51:51 | [B14 - Another Subset Sum](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_cm) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [Python (CPython 3.11.4)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5055) | 1000 | 1039 Byte |  | 85 ms | 13228 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67446056) |
+| 2025-07-09 16:33:32 | [B14 - Another Subset Sum](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_cm) | [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 | 1382 Byte |  | 57 ms | 48880 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67445536) |
+| 2025-07-09 16:28:53 | [B14 - Another Subset Sum](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_cm) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [JavaScript (Node.js 18.16.1)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5009) | 1000 | 1191 Byte |  | 79 ms | 48856 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67445383) |
\ No newline at end of file