From 4abfced5625a3b725de78bcfc64430e64b5ae93a Mon Sep 17 00:00:00 2001
From: myoshizumi <myoshizumi@alumni.berklee.edu>
Date: Tue, 15 Jul 2025 21:59:21 +0900
Subject: [PATCH] atcoder B21 - Longest Subpalindrome DP

---
 .../DynamicProgramming/atCoder/B21/B21.go     | 107 +++++++++++
 .../DynamicProgramming/atCoder/B21/B21.js     |  91 +++++++++
 .../DynamicProgramming/atCoder/B21/B21.php    |  96 ++++++++++
 .../DynamicProgramming/atCoder/B21/B21.py     |  90 +++++++++
 .../DynamicProgramming/atCoder/B21/B21.ts     |  71 +++++++
 .../DynamicProgramming/atCoder/B21/README.md  | 174 ++++++++++++++++++
 6 files changed, 629 insertions(+)
 create mode 100644 Algorithm/DynamicProgramming/atCoder/B21/B21.go
 create mode 100644 Algorithm/DynamicProgramming/atCoder/B21/B21.js
 create mode 100644 Algorithm/DynamicProgramming/atCoder/B21/B21.php
 create mode 100644 Algorithm/DynamicProgramming/atCoder/B21/B21.py
 create mode 100644 Algorithm/DynamicProgramming/atCoder/B21/B21.ts
 create mode 100644 Algorithm/DynamicProgramming/atCoder/B21/README.md

diff --git a/Algorithm/DynamicProgramming/atCoder/B21/B21.go b/Algorithm/DynamicProgramming/atCoder/B21/B21.go
new file mode 100644
index 00000000..2a6ca3c7
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/B21/B21.go
@@ -0,0 +1,107 @@
+// 以下に、**Go (go 1.20.6)** を用いて「最長回文部分列の長さ（Longest Palindromic Subsequence）」を求める実装を提示します。
+// **型を明示**し、\*\*処理時間・メモリ制約（1秒・1024MiB）\*\*を満たすよう設計しています。
+
+// ---
+
+// ## ✅ 実装（Go）
+
+// ```go
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+)
+
+// longestPalindromicSubsequence は、与えられた文字列 S に対して、削除のみで構成可能な
+// 最長の回文部分列の長さを返します。
+// パラメータ:
+//   - s string : 英小文字からなる入力文字列（長さ N）
+// 戻り値:
+//   - int : 最長の回文部分列の長さ
+func longestPalindromicSubsequence(s string) int {
+	n := len(s)
+
+	// dp[i][j] := s[i..j] の最長回文部分列の長さ
+	dp := make([][]int, n)
+	for i := range dp {
+		dp[i] = make([]int, n)
+	}
+
+	// 長さ1の部分列は常に回文
+	for i := 0; i < n; i++ {
+		dp[i][i] = 1
+	}
+
+	// 長さ2以上の部分列についてのDP
+	for length := 2; length <= n; length++ {
+		for i := 0; i <= n-length; i++ {
+			j := i + length - 1
+			if s[i] == s[j] {
+				if length == 2 {
+					dp[i][j] = 2
+				} else {
+					dp[i][j] = dp[i+1][j-1] + 2
+				}
+			} else {
+				if dp[i+1][j] > dp[i][j-1] {
+					dp[i][j] = dp[i+1][j]
+				} else {
+					dp[i][j] = dp[i][j-1]
+				}
+			}
+		}
+	}
+
+	return dp[0][n-1]
+}
+
+func main() {
+	scanner := bufio.NewScanner(os.Stdin)
+	scanner.Scan()
+	// 入力 N は使用しないが、読み取りだけ行う
+	_ = scanner.Text()
+
+	scanner.Scan()
+	s := strings.TrimSpace(scanner.Text())
+
+	result := longestPalindromicSubsequence(s)
+	fmt.Println(result)
+}
+
+// ## ✅ 入力例と出力
+
+// ### 入力:
+
+// ```
+// 11
+// programming
+// ```
+
+// ### 出力:
+
+// ```
+// 4
+// ```
+
+// ---
+
+// ## ✅ 時間・メモリの分析
+
+// | 項目     | 分析内容                    |
+// | ------ | ----------------------- |
+// | 時間計算量  | O(N^2)（最大1000×1000）     |
+// | 空間計算量  | O(N^2)（1000×1000 int配列） |
+// | メモリ使用量 | 約4〜8MB（int型が4〜8バイト）     |
+// | 実行時間制限 | 約1秒 → Goの速度で余裕あり        |
+// | メモリ制限  | 1024 MiB → 問題なし         |
+
+// ---
+
+// ## ✅ 備考
+
+// * 入力制約から N ≤ 1000 のため、2次元DPでも十分高速かつ低メモリです。
+// * 回文の中身を復元することも可能ですが、今回は「長さ」だけを効率的に求めます。
+// * `bufio.Scanner` を使用して高速に標準入力を処理しています。
diff --git a/Algorithm/DynamicProgramming/atCoder/B21/B21.js b/Algorithm/DynamicProgramming/atCoder/B21/B21.js
new file mode 100644
index 00000000..1ed5795d
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/B21/B21.js
@@ -0,0 +1,91 @@
+// 以下に、**最長部分回文部分列（Longest Palindromic Subsequence）** を求める JavaScript (Node.js) のコードを、`fs` モジュールを使って記述します。
+
+// ---
+
+// ### ✅ アルゴリズム概要：
+
+// * 動的計画法（DP）を用いて、部分文字列 `S[i..j]` の中で作れる最長回文部分列の長さを `dp[i][j]` に記録していきます。
+// * `dp[i][j]` の計算式：
+
+//   * `S[i] === S[j]` のとき: `dp[i][j] = dp[i+1][j-1] + 2`
+//   * それ以外: `dp[i][j] = max(dp[i+1][j], dp[i][j-1])`
+
+// ---
+
+// ### ✅ 実装（Node.js, `fs` 使用）
+
+// ```javascript
+const fs = require("fs");
+
+/**
+ * 最長回文部分列の長さを返す関数
+ * @param {string} S - 対象の文字列（英小文字）
+ * @returns {number} - 最長の回文部分列の長さ
+ */
+function longestPalindromicSubsequence(S) {
+    const N = S.length;
+    const dp = Array.from({ length: N }, () => Array(N).fill(0));
+
+    // 1文字は必ず回文
+    for (let i = 0; i < N; i++) {
+        dp[i][i] = 1;
+    }
+
+    // 長さ2以上の部分列に対するDP
+    for (let len = 2; len <= N; len++) {
+        for (let i = 0; i <= N - len; i++) {
+            const j = i + len - 1;
+            if (S[i] === S[j]) {
+                dp[i][j] = (len === 2) ? 2 : dp[i + 1][j - 1] + 2;
+            } else {
+                dp[i][j] = Math.max(dp[i + 1][j], dp[i][j - 1]);
+            }
+        }
+    }
+
+    return dp[0][N - 1];
+}
+
+// 入力読み取り
+const input = fs.readFileSync("/dev/stdin", "utf8").trim().split("\n");
+const N = Number(input[0]);
+const S = input[1];
+
+// 出力
+console.log(longestPalindromicSubsequence(S));
+
+// ### ✅ 入力例での動作確認
+
+// #### 入力:
+
+// ```
+// 11
+// programming
+// ```
+
+// #### 出力:
+
+// ```
+// 4
+// ```
+
+// #### 入力:
+
+// ```
+// 7
+// abcdcba
+// ```
+
+// #### 出力:
+
+// ```
+// 7
+// ```
+
+// ---
+
+// ### ✅ 時間・メモリ計算
+
+// * **時間計算量**：O(N^2) （N ≦ 1000なので最大で約 1,000,000 ループ）
+// * **空間計算量**：O(N^2) （1000×1000 の 2次元配列 → 約 8MB）
+
diff --git a/Algorithm/DynamicProgramming/atCoder/B21/B21.php b/Algorithm/DynamicProgramming/atCoder/B21/B21.php
new file mode 100644
index 00000000..40d9d350
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/B21/B21.php
@@ -0,0 +1,96 @@
+<!-- 以下に、**PHP 8.2.8** を用いた「最長回文部分列の長さ（Longest Palindromic Subsequence）」を求めるコードを提示します。
+**型指定・関数化・処理時間とメモリ効率を考慮**した実装です。
+
+---
+
+## ✅ PHPコード（標準入力＋DPでの最長回文部分列）
+
+<?php
+
+declare(strict_types=1);
+
+/**
+ * 与えられた文字列 S に対し、削除のみで構成可能な最長回文部分列の長さを求める。
+ *
+ * @param string $s 入力文字列（英小文字のみ）
+ * @return int 最長回文部分列の長さ
+ */
+function longestPalindromicSubsequence(string $s): int
+{
+    $n = strlen($s);
+
+    // dp[i][j] := S[i..j]の最長回文部分列の長さ
+    $dp = array_fill(0, $n, array_fill(0, $n, 0));
+
+    // 長さ1の部分列は常に回文（自己一致）
+    for ($i = 0; $i < $n; $i++) {
+        $dp[$i][$i] = 1;
+    }
+
+    // 部分列の長さ2からnまでのDP
+    for ($length = 2; $length <= $n; $length++) {
+        for ($i = 0; $i <= $n - $length; $i++) {
+            $j = $i + $length - 1;
+
+            if ($s[$i] === $s[$j]) {
+                $dp[$i][$j] = ($length === 2) ? 2 : $dp[$i + 1][$j - 1] + 2;
+            } else {
+                $dp[$i][$j] = max($dp[$i + 1][$j], $dp[$i][$j - 1]);
+            }
+        }
+    }
+
+    return $dp[0][$n - 1];
+}
+
+// 標準入力からの読み取り処理（複数行）
+$input = explode("\n", trim(file_get_contents("php://stdin")));
+$n = (int)$input[0];
+$s = $input[1];
+
+// 関数呼び出しと出力
+$result = longestPalindromicSubsequence($s);
+echo $result . PHP_EOL;
+
+// ## ✅ 入力例と出力
+
+// ### 入力：
+
+// ```
+// 11
+// programming
+// ```
+
+// ### 出力：
+
+// ```
+// 4
+// ```
+
+// ---
+
+// ## ✅ 処理量の見積もり
+
+// | 項目     | 値                           |
+// | ------ | --------------------------- |
+// | 時間計算量  | O(N²)（最大 1000 × 1000 = 10⁶） |
+// | 空間計算量  | O(N²)（1000×1000 要素）≈ 4〜8MB  |
+// | メモリ制限  | 1024 MiB → 問題なし             |
+// | 実行時間制限 | 1秒 → 通常の PHP 実行でも問題なし       |
+
+// ---
+
+// ## ✅ 型とコメントに関する補足
+
+// * PHP 8.2 では関数の戻り値型 (`int`) や引数型 (`string`) が厳密にサポートされています。
+// * `$dp` は二次元配列 `int[][]` で、PHPの動的配列構造を使用。
+// * 配列初期化は `array_fill()` を使って高速・省メモリ化。
+
+// ---
+
+// ## ✅ 追加対応可能な事項
+
+// * 実際の回文を**復元して出力する拡張バージョン**
+// * メモリ最適化（1次元DP化）※可能だが読みづらくなる
+
+// ご希望があれば続けてご提供可能です。
\ No newline at end of file
diff --git a/Algorithm/DynamicProgramming/atCoder/B21/B21.py b/Algorithm/DynamicProgramming/atCoder/B21/B21.py
new file mode 100644
index 00000000..ee88e41c
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/B21/B21.py
@@ -0,0 +1,90 @@
+# 以下に、**Python (CPython 3.11.4)** を用いて「最長回文部分列の長さ」を求める実装を提示します。
+# また、**型アノテーション・関数構造・処理時間およびメモリ効率**を重視しています。
+
+# ---
+
+# ## ✅ 実装（Python）
+
+# ```python
+import sys
+
+# 型アノテーションのインポート（任意）
+from typing import List
+
+def longest_palindromic_subsequence(S: str) -> int:
+    """
+    与えられた文字列 S に対して、削除操作のみで構成可能な最長の回文部分列の長さを返す。
+
+    Parameters:
+    - S (str): 入力文字列（英小文字のみ）
+
+    Returns:
+    - int: 最長回文部分列の長さ
+    """
+
+    N: int = len(S)
+    # dp[i][j] は S[i..j] における最長回文部分列の長さ
+    dp: List[List[int]] = [[0] * N for _ in range(N)]
+
+    # 長さ1の部分列は必ず回文
+    for i in range(N):
+        dp[i][i] = 1
+
+    # 長さ2以上の部分列に対するDP
+    for length in range(2, N + 1):         # 長さ 2 から N
+        for i in range(N - length + 1):
+            j = i + length - 1
+            if S[i] == S[j]:
+                if length == 2:
+                    dp[i][j] = 2
+                else:
+                    dp[i][j] = dp[i + 1][j - 1] + 2
+            else:
+                dp[i][j] = max(dp[i + 1][j], dp[i][j - 1])
+
+    return dp[0][N - 1]
+
+# --- 入力処理 ---
+def main() -> None:
+    input_lines = sys.stdin.read().splitlines()
+    _: int = int(input_lines[0])
+    S: str = input_lines[1]
+    
+    result: int = longest_palindromic_subsequence(S)
+    print(result)
+
+if __name__ == "__main__":
+    main()
+
+# ## ✅ 入力例
+
+# 標準入力で以下のように与えると：
+
+# ```
+# 11
+# programming
+# ```
+
+# 出力：
+
+# ```
+# 4
+# ```
+
+# ---
+
+# ## ✅ 時間・空間計算量
+
+# | 項目    | 値        | 説明                  |
+# | ----- | -------- | ------------------- |
+# | 時間計算量 | `O(N^2)` | 二重ループ（最大1000×1000）  |
+# | 空間計算量 | `O(N^2)` | 二次元リスト（最大1000×1000） |
+
+# * `N = 1000` の場合でも、2次元配列は約4MB（Pythonの整数で1要素8バイト想定） → **余裕で収まります（制限1024MiB）**
+# * 実行時間は最大でも **100万ステップ程度**なので、CPython 3.11.4でも1秒以内で完了します。
+
+# ---
+
+# ## ✅ 補足：DPテーブルを1次元に圧縮することも可能？
+
+# はい、理論上は可能ですが、今回のように `dp[i+1][j-1]` を参照する遷移がある場合は「全ての状態を保持」していないと正しく計算できないため、**2次元テーブルが妥当**です。
diff --git a/Algorithm/DynamicProgramming/atCoder/B21/B21.ts b/Algorithm/DynamicProgramming/atCoder/B21/B21.ts
new file mode 100644
index 00000000..e6616cc8
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/B21/B21.ts
@@ -0,0 +1,71 @@
+// 以下は、**最長回文部分列の長さ**を求めるTypeScriptコードです。
+// Node.jsの`fs`モジュールを使用して標準入力を読み取り、**処理時間とメモリの制約（1秒 / 1024MiB）を意識**した実装になっています。
+
+// ---
+
+// ## ✅ 実装（TypeScript）
+
+// ```ts
+import * as fs from 'fs';
+
+/**
+ * 与えられた文字列に対し、最長の回文部分列の長さを返す関数。
+ * @param S - 対象の文字列（英小文字）
+ * @returns number - 最長の回文部分列の長さ
+ */
+function longestPalindromicSubsequence(S: string): number {
+    const N: number = S.length;
+
+    // dp[i][j] = S[i..j]で作れる最長回文部分列の長さ
+    const dp: number[][] = Array.from({ length: N }, () => new Array(N).fill(0));
+
+    // 1文字は常に回文
+    for (let i = 0; i < N; i++) {
+        dp[i][i] = 1;
+    }
+
+    // 部分文字列の長さlen=2からNまで
+    for (let len = 2; len <= N; len++) {
+        for (let i = 0; i <= N - len; i++) {
+            const j = i + len - 1;
+            if (S[i] === S[j]) {
+                dp[i][j] = (len === 2) ? 2 : dp[i + 1][j - 1] + 2;
+            } else {
+                dp[i][j] = Math.max(dp[i + 1][j], dp[i][j - 1]);
+            }
+        }
+    }
+
+    return dp[0][N - 1];
+}
+
+// --- 入力処理 ---
+const input: string[] = fs.readFileSync("/dev/stdin", "utf8").trim().split("\n");
+const N: number = Number(input[0]);
+const S: string = input[1];
+
+// --- 実行と出力 ---
+const result: number = longestPalindromicSubsequence(S);
+console.log(result);
+
+// ## ✅ 使用方法（例）
+
+// 標準入力に以下を渡すと:
+
+// ```
+// 11
+// programming
+// ```
+
+// 出力は：
+
+// ```
+// 4
+// ```
+
+// ---
+
+// ## ✅ 時間・メモリ制約に関して
+
+// * **時間計算量**：`O(N^2)`（最大で1,000×1,000 = 1,000,000ループ）→ 1秒以内に収まります。
+// * **空間計算量**：`O(N^2)` → `1000 * 1000 * 4バイト = 約4MB`（メモリ制限1024MiBに対して非常に軽量）
diff --git a/Algorithm/DynamicProgramming/atCoder/B21/README.md b/Algorithm/DynamicProgramming/atCoder/B21/README.md
new file mode 100644
index 00000000..d96a4e9e
--- /dev/null
+++ b/Algorithm/DynamicProgramming/atCoder/B21/README.md
@@ -0,0 +1,174 @@
+以下では、TypeScriptで実装した **「最長回文部分列 (Longest Palindromic Subsequence, LPS)」** において、各処理が何をしているのかを **図解・解析付きで詳細に解説** します。
+
+---
+
+## 🧩 問題の本質
+
+「文字列からいくつかの文字を取り除いてできる最長の**回文部分列**の長さ」を求める問題です。
+
+---
+
+## 🔧 使用アルゴリズム：**動的計画法 (DP)**
+
+以下のような2次元DP配列 `dp[i][j]` を使って、**S\[i..j] の範囲で作れる最長回文部分列の長さ**を記録します。
+
+---
+
+## 📘 入力例と構造の確認
+
+### 入力：
+
+```
+S = "programming"
+         ↑
+      N = 11
+```
+
+---
+
+## 🧮 初期化：1文字は必ず回文
+
+```ts
+for (let i = 0; i < N; i++) {
+    dp[i][i] = 1;
+}
+```
+
+### ✅ 図解（初期状態）
+
+```text
+dp = 11x11 の配列（全て 0 で初期化）
+
+   p r o g r a m m i n g
+p  1 . . . . . . . . . .
+r  . 1 . . . . . . . . .
+o  . . 1 . . . . . . . .
+g  . . . 1 . . . . . . .
+r  . . . . 1 . . . . . .
+a  . . . . . 1 . . . . .
+m  . . . . . . 1 . . . .
+m  . . . . . . . 1 . . .
+i  . . . . . . . . 1 . .
+n  . . . . . . . . . 1 .
+g  . . . . . . . . . . 1
+```
+
+---
+
+## 🔁 遷移式の構築（長さ2以上の部分列）
+
+```ts
+for (let len = 2; len <= N; len++) {
+  for (let i = 0; i <= N - len; i++) {
+    const j = i + len - 1;
+    if (S[i] === S[j]) {
+      dp[i][j] = dp[i + 1][j - 1] + 2;
+    } else {
+      dp[i][j] = Math.max(dp[i + 1][j], dp[i][j - 1]);
+    }
+  }
+}
+```
+
+---
+
+### ✅ 図解：`dp[i][j]`の意味と更新方針
+
+#### S = "gmmg" の例で考える（インデックス付き）
+
+```text
+S = g m m g
+     0 1 2 3
+```
+
+* `dp[0][3]`: S\[0] = 'g', S\[3] = 'g' → 端が一致！
+* 中央部 dp\[1]\[2] は 'mm' → 回文なので長さ2
+* よって dp\[0]\[3] = dp\[1]\[2] + 2 = 4
+
+```text
+dp 配列の一部更新
+
+   g m m g
+g  1 . . 4
+m  . 1 2 .
+m  . . 1 .
+g  . . . 1
+```
+
+---
+
+### ✅ `S[i] === S[j]` の場合：
+
+```ts
+dp[i][j] = dp[i+1][j-1] + 2
+```
+
+→ 両端が同じなら、内側を包むように回文が延長される。
+
+---
+
+### ✅ `S[i] !== S[j]` の場合：
+
+```ts
+dp[i][j] = Math.max(dp[i+1][j], dp[i][j-1])
+```
+
+→ 片方を捨てて最長回文を保つ選択を行う。
+
+---
+
+## ✅ 全体図（"programming" の dp テーブル概略）
+
+下記は完成したdpテーブルの一部（概略）です。
+
+```text
+   0 1 2 3 4 5 6 7 8 9 10
+ p r o g r a m m i n  g
+[1 . . . . . . . . . . ]
+[. 1 . . . . . . . . . ]
+[. . 1 . . . . . . . . ]
+[. . . 1 . . . . . . . ]
+[. . . . 1 . . . . . . ]
+[. . . . . 1 . . . . . ]
+[. . . . . . 1 . . . . ]
+[. . . . . . . 1 . . . ]
+[. . . . . . . . 1 . . ]
+[. . . . . . . . . 1 . ]
+[. . . . . . . . . . 1 ]
+```
+
+この中で、`dp[0][10]`（=全体での最長回文長）が最終答になります。
+
+例：`programming` → `gmmg` を残すことで「長さ4」の回文が作れる
+
+---
+
+## ✅ 処理のまとめ表
+
+| ステップ    | 内容                     | 計算量    |
+| ------- | ---------------------- | ------ |
+| 入力      | 標準入力から読み取り (`fs`)      | O(N)   |
+| 配列初期化   | `dp[i][i] = 1`（1文字は回文） | O(N)   |
+| DP更新ループ | `dp[i][j]` の2重ループ      | O(N^2) |
+| 出力      | `dp[0][N-1]` を出力       | O(1)   |
+
+---
+
+## 📈 時間・空間計算量
+
+* **時間計算量**：`O(N^2)`（最大 1,000×1,000 = 10^6）
+* **空間計算量**：`O(N^2)`（約4MB）
+
+---
+
+## ✅ 最後に
+
+この手法は、\*\*文字の並び替えができない場合の「削除のみ許される回文問題」\*\*で有効な典型解法です。
+
+| [提出日時](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-15 21:54:11 | [B21 - Longest Subpalindrome](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_ct) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [Go (go 1.20.6)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5002) | 1000 | 1412 Byte |  | 7 ms | 8188 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67625944) |
+| 2025-07-15 21:45:46 | [B21 - Longest Subpalindrome](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_ct) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [PHP (php 8.2.8)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5016) | 1000 | 1336 Byte |  | 47 ms | 37492 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67625790) |
+| 2025-07-15 21:43:46 | [B21 - Longest Subpalindrome](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_ct) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [Python (CPython 3.11.4)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5055) | 1000 | 1417 Byte |  | 140 ms | 25636 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67625751) |
+| 2025-07-15 21:36:41 | [B21 - Longest Subpalindrome](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_ct) | [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 | 1302 Byte |  | 62 ms | 61304 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67625616) |
+| 2025-07-15 21:32:44 | [B21 - Longest Subpalindrome](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_ct) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [JavaScript (Node.js 18.16.1)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5009) | 1000 | 1080 Byte |  | 77 ms | 60920 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/67625528) |
\ No newline at end of file