From 3e96d0aa43da40223ec359250a2a40d132ff4e0e Mon Sep 17 00:00:00 2001
From: myoshizumi <myoshizumi@alumni.berklee.edu>
Date: Mon, 7 Jul 2025 19:29:29 +0900
Subject: [PATCH] =?UTF-8?q?atcoder=20B12=20-=20Equation=20=E4=BA=8C?=
 =?UTF-8?q?=E5=88=86=E6=8E=A2=E7=B4=A2?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 Algorithm/BinarySearch/atCoder/B12/B12.go    | 116 ++++++++++++
 Algorithm/BinarySearch/atCoder/B12/B12.js    |  54 ++++++
 Algorithm/BinarySearch/atCoder/B12/B12.php   | 110 +++++++++++
 Algorithm/BinarySearch/atCoder/B12/B12.py    |  93 +++++++++
 Algorithm/BinarySearch/atCoder/B12/B12.ts    |  63 +++++++
 Algorithm/BinarySearch/atCoder/B12/README.md | 187 +++++++++++++++++++
 6 files changed, 623 insertions(+)
 create mode 100644 Algorithm/BinarySearch/atCoder/B12/B12.go
 create mode 100644 Algorithm/BinarySearch/atCoder/B12/B12.js
 create mode 100644 Algorithm/BinarySearch/atCoder/B12/B12.php
 create mode 100644 Algorithm/BinarySearch/atCoder/B12/B12.py
 create mode 100644 Algorithm/BinarySearch/atCoder/B12/B12.ts
 create mode 100644 Algorithm/BinarySearch/atCoder/B12/README.md

diff --git a/Algorithm/BinarySearch/atCoder/B12/B12.go b/Algorithm/BinarySearch/atCoder/B12/B12.go
new file mode 100644
index 00000000..8fed25cc
--- /dev/null
+++ b/Algorithm/BinarySearch/atCoder/B12/B12.go
@@ -0,0 +1,116 @@
+// 以下は、Go言語（Golang）を用いて方程式 $x^3 + x = N$ を満たす正の実数 $x$ を **二分探索で求めるコード**です。
+// **型を明示**し、**処理時間とメモリ消費量**にも配慮しています。
+
+// ## ✅ 解法：二分探索
+
+// * 関数 $f(x) = x^3 + x$ は **単調増加関数**なので、**二分探索**が有効。
+// * 解の誤差が **絶対または相対誤差 0.001 以下**になるまで探索。
+// * Go の `float64` を使い、収束精度は十分。
+
+// ## ✅ Go 実装コード（型明示）
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"math"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func main() {
+	// 標準入力読み込み
+	reader := bufio.NewReader(os.Stdin)
+	line, _ := reader.ReadString('\n')
+	NStr := strings.TrimSpace(line)
+	N, err := strconv.ParseFloat(NStr, 64)
+	if err != nil {
+		panic(err)
+	}
+
+	// 型: float64
+	var low float64 = 0.0
+	var high float64 = math.Max(1.0, N)
+	var mid float64
+
+	for i := 0; i < 100; i++ {
+		mid = (low + high) / 2
+		f := mid*mid*mid + mid // f(x) = x^3 + x
+		if f > N {
+			high = mid
+		} else {
+			low = mid
+		}
+	}
+
+	// 小数点6桁まで出力
+	fmt.Printf("%.6f\n", mid)
+}
+
+// ## ✅ 使用例
+
+// ### 入力:
+
+// ```
+// 2
+// ```
+
+// ### 出力:
+
+// ```
+// 1.000000
+// ```
+
+// ---
+
+// ## ✅ 型の明示について
+
+// | 変数名    | 型         | 説明              |
+// | ------ | --------- | --------------- |
+// | `N`    | `float64` | 入力値（正の実数）       |
+// | `low`  | `float64` | 二分探索の下限         |
+// | `high` | `float64` | 二分探索の上限         |
+// | `mid`  | `float64` | 探索中間値（出力対象）     |
+// | `f`    | `float64` | 計算された関数値 $f(x)$ |
+
+// ---
+
+// ## ✅ 処理時間・メモリ消費量の目安（Go）
+
+// | 指標     | 内容                        |
+// | ------ | ------------------------- |
+// | 時間計算量  | $O(\log N)$（最大100ステップ）    |
+// | 実行時間   | 約 1〜2 ms（Go 1.20以降の標準ビルド） |
+// | メモリ使用量 | 数MB（浮動小数 + 入出力バッファのみ）     |
+
+// ---
+
+// ## ✅ なぜ100回ループするのか？
+
+// * $2^{-20} ≈ 10^{-6}$ なので、誤差 $\leq 0.001$ にするには20〜30回で十分。
+// * **100回のループ**にすることで安全に収束するようにしている。
+
+// ---
+
+// ## ✅ 簡易図解：探索の流れ
+
+// ```
+// f(x) = x^3 + x の単調増加
+
+// 探索範囲:
+// [low]----------------[high]
+//  0.0                   N
+
+// 繰り返しで収束:
+// [0.0 .......... mid .......... N]
+//          ↓
+// [0.0 ...... mid ......]
+//          ↓
+// [mid - ε ... mid + ε] ≈ 解
+// ```
+
+// ---
+
+// Goでは `float64` の精度で十分な誤差範囲（0.001）に収束できます。
+// ご希望があれば、誤差制御をループ回数ではなく **相対誤差判定で停止**させる改良も可能です。
diff --git a/Algorithm/BinarySearch/atCoder/B12/B12.js b/Algorithm/BinarySearch/atCoder/B12/B12.js
new file mode 100644
index 00000000..3f8f2a6e
--- /dev/null
+++ b/Algorithm/BinarySearch/atCoder/B12/B12.js
@@ -0,0 +1,54 @@
+// 以下は、与えられた方程式 $x^3 + x = N$ を満たす正の実数 $x$ を **2分探索**で求める JavaScript コードです。
+// `fs` モジュールを使用して標準入力から値を読み取り、解の精度は絶対誤差または相対誤差が 0.001 以下になるまで繰り返します。
+
+// ### ✅ 解法：二分探索（精度重視）
+
+// * 解となる $x$ は単調増加な関数 $f(x) = x^3 + x$ によって定まる。
+// * よって、1 ≦ N ≦ 100000 の範囲で、右端を十分大きな値（例：N）にして探索。
+
+// ### ✅ JavaScript 実装（`fs`使用）
+
+const fs = require("fs");
+
+const input = fs.readFileSync("/dev/stdin", "utf8").trim();
+const N = parseFloat(input);
+
+// x^3 + x = N を満たす x を求める（絶対/相対誤差 0.001 以下）
+let low = 0.0;
+let high = Math.max(1, N);  // N=1のときに0〜1の範囲に解があることを保証
+let mid;
+
+for (let i = 0; i < 100; i++) {  // 高速に収束するため100回で十分
+    mid = (low + high) / 2;
+    const f = mid ** 3 + mid;
+    if (f > N) {
+        high = mid;
+    } else {
+        low = mid;
+    }
+}
+
+console.log(mid.toFixed(6));
+
+// ### ✅ 処理時間・メモリ消費量
+
+// * **計算量**：O(log₂(N)) ≒ 100ステップ未満で収束。
+// * **メモリ使用**：10MB 未満（fs + 数値計算のみ）
+// * **実行時間**：平均 2〜5ms（Node.js v18+）
+
+// ---
+
+// ### ✅ 入力例の動作確認
+
+// #### 入力:
+
+// ```
+// 2
+// ```
+
+// #### 出力:
+
+// ```
+// 1.000000
+// ```
+
diff --git a/Algorithm/BinarySearch/atCoder/B12/B12.php b/Algorithm/BinarySearch/atCoder/B12/B12.php
new file mode 100644
index 00000000..9d5e4e2a
--- /dev/null
+++ b/Algorithm/BinarySearch/atCoder/B12/B12.php
@@ -0,0 +1,110 @@
+<!-- 以下は、PHP を用いて方程式 $x^3 + x = N$ を満たす正の実数 $x$ を求めるプログラムです。
+**型を明示的に記述しつつ、処理時間およびメモリ使用量にも配慮**しています。
+
+## ✅ 解法方針：二分探索（Binary Search）
+
+* $f(x) = x^3 + x$ は単調増加 ⇒ 二分探索で一意に解を求められる。
+* 精度は **絶対誤差または相対誤差 ≤ 0.001** で十分。
+* 反復回数を固定（例：100回）とすることで、誤差 $\leq 10^{-6}$ を保証。
+
+## ✅ PHP 実装（型付きコメント付き）
+<?php
+declare(strict_types=1);
+
+// 入力読み込み
+$input = trim(fgets(STDIN));
+$N = floatval($input);
+
+// 初期範囲の設定（型明示: float）
+$low = 0.0;
+$high = max(1.0, $N);
+$mid = 0.0;
+
+// 二分探索：誤差 0.001 以下まで収束
+for ($i = 0; $i < 100; $i++) {
+    $mid = ($low + $high) / 2.0;
+    $f = $mid * $mid * $mid + $mid; // f(x) = x^3 + x
+
+    if ($f > $N) {
+        $high = $mid;
+    } else {
+        $low = $mid;
+    }
+}
+
+// 結果出力（小数第6位まで）
+printf("%.6f\n", $mid);
+
+// ## ✅ 入出力例
+
+// ### 入力:
+
+// ```
+// 2
+// ```
+
+// ### 出力:
+
+// ```
+// 1.000000
+// ```
+
+// ---
+
+// ## ✅ 処理時間・メモリ消費量（目安）
+
+// | 指標     | 内容                     |
+// | ------ | ---------------------- |
+// | 時間計算量  | $O(\log N)$（最大100ステップ） |
+// | 実行時間   | 約 1～3 ms（PHP 8.x CLI）  |
+// | メモリ使用量 | 数 MB 程度（浮動小数とループのみ）    |
+
+// ---
+
+// ## ✅ なぜ100回ループするのか？
+
+// * 各ステップで範囲は半分になる（二分探索）。
+// * $2^{-20} ≈ 10^{-6}$ ⇒ **20～30回で十分**。
+// * **100回回せば誤差 0.001 以下が保証**される。
+
+// ---
+
+// ## ✅ 型の明示（PHP ではコメントベース）
+
+// PHP 8 では以下のような明示が可能：
+
+// ```php
+// /** @var float $low */
+// /** @var float $high */
+// /** @var float $mid */
+// ```
+
+// ---
+
+// ## ✅ グラフのイメージ（探索）
+
+// ```
+// y = x^3 + x  のグラフ
+
+//   y
+//   ^
+//   |                             ●
+//   |                        ●
+//   |                   ●
+//   |              ●
+//   |         ●
+//   |    ●
+//   |●
+//   +----------------------------→ x
+
+//  探索範囲が収束：
+//  [0 .............. N]
+//  [0 ....... mid]
+//  [mid ... high]
+//    ︙
+//  [1.0000 ± ε]
+// ```
+
+// ---
+
+// ご希望があれば、BCMath による任意精度演算対応や、PHPUnit を使ったテストコードの追加も可能です。
\ No newline at end of file
diff --git a/Algorithm/BinarySearch/atCoder/B12/B12.py b/Algorithm/BinarySearch/atCoder/B12/B12.py
new file mode 100644
index 00000000..156b0f6c
--- /dev/null
+++ b/Algorithm/BinarySearch/atCoder/B12/B12.py
@@ -0,0 +1,93 @@
+# 以下は、与えられた方程式 $x^3 + x = N$ を満たす正の実数 $x$ を **Python** で求める実装です。
+# **型指定付き**で記述し、**処理時間・メモリ使用量**に配慮しています。
+
+# ---
+
+# ## ✅ 解法概要：二分探索
+
+# * 関数 $f(x) = x^3 + x$ は単調増加なので、2分探索が有効。
+# * $x \in (0, N)$ の範囲で探索し、**相対誤差 or 絶対誤差 ≤ 0.001** になるまで繰り返します。
+
+# ---
+
+# ## ✅ Python 実装（型付き）
+import sys
+# from typing import Tuple
+
+def solve() -> None:
+    input_str: str = sys.stdin.read().strip()
+    N: float = float(input_str)
+
+    low: float = 0.0
+    high: float = max(1.0, N)
+    mid: float = 0.0
+
+    for _ in range(100):
+        mid = (low + high) / 2
+        f: float = mid**3 + mid
+        if f > N:
+            high = mid
+        else:
+            low = mid
+
+    print(f"{mid:.6f}")
+
+if __name__ == "__main__":
+    solve()
+# ```
+
+# ---
+
+# ## ✅ 使用例
+
+# ### 入力:
+
+# ```
+# 2
+# ```
+
+# ### 出力:
+
+# ```
+# 1.000000
+# ```
+
+# ---
+
+# ## ✅ 処理時間・メモリ使用量の目安
+
+# | 指標         | 内容                      |
+# | ---------- | ----------------------- |
+# | **時間計算量**  | $O(\log N)$（収束まで100回以下） |
+# | **実行時間**   | 約 1〜3 ms（CPython 3.8+）  |
+# | **メモリ使用量** | 約 10〜20MB（標準ライブラリ＋浮動小数） |
+
+# ---
+
+# ## ✅ 解説図（簡易）
+
+# ```text
+# 探索範囲:
+#    ┌──────────────┐
+# low│              │high
+#  0.0              N
+
+# 収束イメージ:
+# 1回目: [0 ............. N]
+# 2回目: [0 ......... mid]
+# 3回目: [mid .. high]
+# ...
+# 最終:  [x - ε .. x + ε]
+# ```
+
+# ---
+
+# ## ✅ なぜ 100 回で十分か？
+
+# * 二分探索により探索幅が $\frac{1}{2^n}$ に。
+# * 精度が $10^{-6}$ 必要なら $n ≈ 20$ 回で十分。
+# * 安全に **100回**繰り返すことで収束を保証。
+
+# ---
+
+# ご希望があれば、NumPy や decimal ライブラリを用いた高精度バージョンも提供可能です。
diff --git a/Algorithm/BinarySearch/atCoder/B12/B12.ts b/Algorithm/BinarySearch/atCoder/B12/B12.ts
new file mode 100644
index 00000000..56bd88f5
--- /dev/null
+++ b/Algorithm/BinarySearch/atCoder/B12/B12.ts
@@ -0,0 +1,63 @@
+// 以下は TypeScript による解答で、`fs` モジュールを使って標準入力から読み込み、2分探索で $x^3 + x = N$ の正の実数解を求めます。
+// 相対・絶対誤差が 0.001 以下になるまで探索し、**精度・速度・メモリ使用量**に配慮しています。
+
+// ## ✅ TypeScript 解答（`fs` 使用）
+
+import * as fs from 'fs';
+
+const input: string = fs.readFileSync('/dev/stdin', 'utf8').trim();
+const N: number = parseFloat(input);
+
+let low: number = 0.0;
+let high: number = Math.max(1.0, N);
+let mid: number = 0.0;
+
+for (let i = 0; i < 100; i++) {
+    mid = (low + high) / 2;
+    const fx = mid ** 3 + mid;
+
+    if (fx > N) {
+        high = mid;
+    } else {
+        low = mid;
+    }
+}
+
+// 出力は誤差 0.001 以下になるように固定小数6桁
+console.log(mid.toFixed(6));
+
+// ## ✅ 実行環境・計算リソース目安
+
+// | 項目         | 内容                              |
+// | ---------- | ------------------------------- |
+// | **計算量**    | O(log(N)) ≒ 100ループで収束           |
+// | **時間目安**   | 約 1〜3ms（Node.js + TypeScript環境） |
+// | **メモリ使用量** | 数MB程度（定数個の変数のみ）                 |
+
+// ---
+
+// ## ✅ 入出力例
+
+// ### 入力:
+
+// ```
+// 2
+// ```
+
+// ### 出力:
+
+// ```
+// 1.000000
+// ```
+
+// ---
+
+// ## ✅ 補足：型の使用について
+
+// * `input: string` 明示的に入力型を宣言。
+// * `N: number`、`low`, `high`, `mid`, `fx` などすべての変数に型を付けています。
+// * 型推論される箇所もありますが、計算誤差に敏感な問題では型明示が安全です。
+
+// ---
+
+// ご希望があれば `readline` ベースの非同期読み取りに変更することも可能です。
diff --git a/Algorithm/BinarySearch/atCoder/B12/README.md b/Algorithm/BinarySearch/atCoder/B12/README.md
new file mode 100644
index 00000000..b0b410f9
--- /dev/null
+++ b/Algorithm/BinarySearch/atCoder/B12/README.md
@@ -0,0 +1,187 @@
+以下では、TypeScript で書かれた「方程式 $x^3 + x = N$ を満たす正の実数 $x$ を求めるプログラム」について、**各処理を図解付きで具体的に説明**します。
+
+---
+
+## 🧠 問題の本質と解法の選定
+
+### 問題式：
+
+$$
+f(x) = x^3 + x = N
+$$
+
+この方程式のグラフは次のような **単調増加関数**です。
+
+```
+  ^
+y |                             ●← y = x^3 + x
+  |                       ●
+  |                 ●
+  |           ●
+  |     ●
+  | ●
+  +-----------------------------→ x
+```
+
+* **x が増えると f(x) も増える（単調増加）** ➜ 二分探索が使える！
+
+---
+
+## 🔧 処理の流れと図解
+
+### ① 入力読み取り（`fs`モジュール）
+
+```ts
+const input: string = fs.readFileSync('/dev/stdin', 'utf8').trim();
+const N: number = parseFloat(input);
+```
+
+#### 🔎 解説：
+
+* ユーザーが入力した $N$ を文字列として受け取り、数値に変換します。
+* 例：`"2"` → `2`
+
+```
+標準入力: "2" ──→ parseFloat ──→ N = 2
+```
+
+---
+
+### ② 二分探索の初期値設定
+
+```ts
+let low: number = 0.0;
+let high: number = Math.max(1.0, N);
+```
+
+#### 🖼 図解：
+
+```
+探索範囲:
+low = 0.0
+high = N（例: 2.0）
+```
+
+> なぜ `high = max(1.0, N)`？
+>
+> * N が 1 未満のときでも解は 0〜1 にあるので安全に解が含まれるようにしている。
+
+---
+
+### ③ 二分探索ループ
+
+```ts
+for (let i = 0; i < 100; i++) {
+    mid = (low + high) / 2;
+    const fx = mid ** 3 + mid;
+
+    if (fx > N) {
+        high = mid;
+    } else {
+        low = mid;
+    }
+}
+```
+
+#### 🖼 ループ内の処理（例：N = 2）
+
+```
+ステップ1：
+  low = 0.0
+  high = 2.0
+  mid = 1.0
+  f(1.0) = 1 + 1 = 2 → 合ってる！収束開始！
+
+ステップ2：
+  low = 0.0
+  high = 1.0
+  mid = 0.5
+  f(0.5) = 0.125 + 0.5 = 0.625 → 小さい → low を上げる！
+
+ステップ3：
+  low = 0.5
+  high = 1.0
+  mid = 0.75
+  f(0.75) = 約1.172 → まだ小さい → low を上げる！
+
+ステップn：
+  ...
+```
+
+#### ⏱ 精度が出るまで繰り返し！
+
+* 二分探索により区間幅は次のように縮小：
+
+```
+最初:   [0.0 ................................................... 2.0]
+         ↓
+次回:   [0.0 ......................... 1.0]
+         ↓
+さらに: [0.5 ............... 1.0]
+         ↓
+最終的に: [0.99999 .. 1.00001]
+```
+
+---
+
+### ④ 結果の出力
+
+```ts
+console.log(mid.toFixed(6));
+```
+
+#### 🔎 解説：
+
+* 絶対誤差または相対誤差が 0.001 以下になる精度で出力（6桁指定）。
+
+#### 🖼 出力イメージ：
+
+```
+結果: mid = 1.000000
+```
+
+---
+
+## 📊 全体処理まとめ図
+
+```
+▼ 入力
+┌─────────────┐
+│  N（整数）   │ ← 標準入力 fs
+└────┬────────┘
+     │
+     ▼
+▼ 二分探索の初期化
+┌─────────────┐
+│ low = 0     │
+│ high = N    │
+└────┬────────┘
+     │
+     ▼
+▼ 反復探索（精度 0.001）
+┌─────────────┐
+│ mid = (low + high) / 2 │
+│ f(mid) = mid³ + mid    │
+│ fx > N → high = mid    │
+│ fx < N → low = mid     │
+└────┬────────┘
+     │（100回繰り返す）
+     ▼
+▼ 結果出力
+┌─────────────┐
+│ mid.toFixed(6) │ → 絶対誤差・相対誤差0.001以下
+└─────────────┘
+```
+
+---
+
+## ✅ 補足：なぜ 100 回で十分か？
+
+* 毎回探索範囲を 1/2 に狭める ⇒ 誤差 $\leq 10^{-6}$ になるには：
+
+  $$
+  2^{-n} \leq 10^{-6} ⇒ n ≈ 20
+  $$
+* つまり **20〜30回**でも十分。**100回**は安全マージン。
+
+---