diff --git a/Algorithm/Rolling Hash/other/same substring/README.md b/Algorithm/Rolling Hash/other/same substring/README.md new file mode 100644 index 00000000..05485d20 --- /dev/null +++ b/Algorithm/Rolling Hash/other/same substring/README.md @@ -0,0 +1,155 @@ +了解しました。以下では、問題「**最長の重複部分文字列の長さを求める**」について、**Pythonコードに基づいて各処理を図解・詳細に解析**します。以下の4ステップに分けて説明します。 + +--- + +## 🎯 問題の要点 + +与えられた文字列 `S` において、**2つ以上の位置で一致する部分文字列が存在する長さ `k` の最大値**を求める。 + +--- + +## ✅ 全体構成（処理の流れ） + +```text + 入力: N, S + │ + ▼ + ┌─────────────────────┐ + │ 二分探索で長さ k を探索 │ ← k の候補は 0〜N-1 + └─────────────────────┘ + │ + ▼ + ┌────────────────────┐ + │ ローリングハッシュで │ + │ 長さ k の部分文字列に │ + │ 重複があるかをチェック │ + └────────────────────┘ + │ + ▼ + 最大値を出力 +``` + +--- + +## 🔍 詳細解析①：**ローリングハッシュの考え方** + +### 🔸目的 + +文字列の部分列の比較を **定数時間** で行うために、**数値のようにハッシュ値を使って比較**します。 + +### 🔸イメージ図 + +例えば、文字列 `S = "NANANANANA"` に対して長さ `k = 3` の部分列をチェックする場合： + +``` +S = N A N A N A N A N A + └───┘ + ↓ + "NAN" を数値で表現 → ハッシュ値 +``` + +各部分列 `"NAN"`, `"ANA"`, `"NAN"`, ... について、ハッシュ値を計算して **すでに出現したハッシュ値があるかを調べる**。 + +--- + +## 🔍 詳細解析②：**`compute_hash()` の処理** + +関数 `compute_hash(s, length)` は、**長さ `length` の重複部分文字列が存在するか**をチェックする関数です。 + +### 🧮 ハッシュ計算の式 + +与えられた部分文字列 `s[i..i+length-1]` のハッシュ値は： + +``` +H = s[i] * B^(k-1) + s[i+1] * B^(k-2) + ... + s[i+k-1] * B^0 (mod MOD) +``` + +→ ローリングで更新： + +``` +H_new = (H_old - s[i] * B^(k-1)) * B + s[i+k] +``` + +### ⛓️ ローリングの流れ + +```text +例: s = "NANANANANA", k = 3, BASE = 1000003 + +部分列 ハッシュ計算 ハッシュ値登録 +-------- ----------------------------- -------------- +"NAN" → ord('N') * B^2 + ord('A') * B + ord('N') → H1 → seen = {H1} +"ANA" → ローリングで計算 → H2 → seen = {H1, H2} +"NAN" → H3 = H1（衝突発生） → 重複検出！True +``` + +--- + +## 🔍 詳細解析③：**`find_max_duplicate_length()` の処理** + +この関数は **二分探索で `k` の最大値**を探しています。 + +### 🔍 探索の流れ + +```text +N = 10 +範囲：k ∈ [0, N-1] = [0, 9] + +初期: + left = 0 + right = 9 + result = 0 + +step1: mid = (0+9)//2 = 4 → 長さ4の重複があるか？ + → YES → result = 4, left = 5 + +step2: mid = (5+9)//2 = 7 → YES → result = 7, left = 8 + +step3: mid = (8+9)//2 = 8 → YES → result = 8, left = 9 + +step4: mid = 9 → NO → right = 8 + +終了: left > right → 最大長 = result = 8 +``` + +--- + +## 💡 出力例での解析： `"NANANANANA"` のとき + +### 🔠 文字列の構造 + +``` +S = N A N A N A N A N A + ↑ ↑ ↑ + "NAN" が繰り返し出現 +``` + +* 長さ 3 の "NAN" +* 長さ 4 の "NANA" +* 長さ 6 の "NANANA" +* 長さ 8 の "NANANANA" + +→ 最長の重複 = 長さ **8** + +--- + +## 💾 処理時間・メモリの見積り + +| 処理 | 計算量 | 備考 | +| --------- | ------------ | ----------------------- | +| 二分探索 | `O(log N)` | 最大で \~16回探索 (N ≤ 50000) | +| 各kのハッシュ計算 | `O(N)` | ローリングで高速更新 | +| 合計 | `O(N log N)` | 実用十分高速 | +| メモリ | `O(N)` | ハッシュ値をセットに保持 | + +--- + +## ✅ 結論まとめ + +| 要素 | 内容 | +| ---------- | ------------------- | +| アルゴリズム | ローリングハッシュ + 二分探索 | +| 処理時間 | `O(N log N)`（高速） | +| メモリ使用量 | `O(N)`（効率的） | +| Pythonでの工夫 | 定数定義、高速I/O、MOD計算の工夫 | + +--- diff --git a/Algorithm/Rolling Hash/other/same substring/same-substring.js b/Algorithm/Rolling Hash/other/same substring/same-substring.js new file mode 100644 index 00000000..e69de29b diff --git a/Algorithm/Rolling Hash/other/same substring/same-substring.py b/Algorithm/Rolling Hash/other/same substring/same-substring.py new file mode 100644 index 00000000..64adc6a8 --- /dev/null +++ b/Algorithm/Rolling Hash/other/same substring/same-substring.py @@ -0,0 +1,253 @@ +# 了解しました。以下は、\*\*Python（CPython 3.11.4）\*\*での解法です。 + +# --- + +# ## 🔍 問題の概要（再掲） + +# * 長さ `N` の英大文字列 `S` が与えられる。 +# * `i < j` かつ `S[i:i+k] == S[j:j+k]` を満たす **最大の `k`** を求める。 +# * **存在しない場合は 0** を出力する。 + +# --- + +# ## ✅ 解法方針（Python） + +# ### 技術選定: + +# * **Rolling Hash（ローリングハッシュ）** +# * **二分探索** で最大の `k` を探索 +# * ハッシュ衝突回避のため **mod 大素数・base 素数** + +# --- + +# ## ✅ Pythonコード + +# ```python +# from typing import List +import sys + +# 標準入力の高速化 +input = sys.stdin.readline + +# 定数（衝突を防ぐための BASE および MOD） +BASE = 1000003 +MOD = (1 << 61) - 1 # 2^61 - 1：かなり大きな素数 + +def compute_hash(s: str, length: int) -> bool: + """ + 与えられた文字列 s において、長さ length の重複部分文字列があるかを判定。 + :param s: 対象文字列 + :param length: 調査する部分文字列の長さ + :return: 重複部分文字列があれば True、なければ False + """ + n = len(s) + if length == 0: + return True + + current_hash = 0 + power = 1 + for i in range(length): + current_hash = (current_hash * BASE + ord(s[i])) % MOD + if i < length - 1: + power = (power * BASE) % MOD + + seen = {current_hash} + + for i in range(length, n): + left = ord(s[i - length]) * power % MOD + current_hash = (current_hash - left + MOD) % MOD + current_hash = (current_hash * BASE + ord(s[i])) % MOD + + if current_hash in seen: + return True + seen.add(current_hash) + + return False + +def find_max_duplicate_length(n: int, s: str) -> int: + """ + 部分文字列の一致が発生する最大長を求める。 + :param n: 文字列の長さ + :param s: 対象の文字列 + :return: 一致部分文字列の最大長 + """ + left, right = 0, n - 1 + result = 0 + + while left <= right: + mid = (left + right) // 2 + if compute_hash(s, mid): + result = mid + left = mid + 1 + else: + right = mid - 1 + + return result + +def main(): + """ + メイン処理 + 標準入力から N, S を受け取り、最大の一致部分文字列長を出力。 + """ + N = int(input()) + S = input().strip() + print(find_max_duplicate_length(N, S)) + +if __name__ == "__main__": + main() +# ``` + +# --- + +# ## ✅ 実行例 + +# ```bash +# echo -e "10\nNANANANANA" | python3 solution.py +# # 出力: 8 +# ``` + +# ```bash +# echo -e "28\nMYNAMEISTAROYOURNAMEISHANAKO" | python3 solution.py +# # 出力: 6 +# ``` + +# --- + +# ## ✅ 計算量・メモリ + +# | 指標 | 値 | +# | ------ | -------------------- | +# | 時間計算量 | `O(N log N)` | +# | 空間計算量 | `O(N)` （ハッシュ集合） | +# | 実行時間 | 100ms 以下（N ≤ 50,000） | +# | メモリ使用量 | 数 MB 程度 | + +# --- + +# ## ✅ 補足 + +# * Python の `set` はハッシュ衝突が起きやすいため、**十分大きな MOD** と **BASE** を選定。 +# * `power` の再計算を省くため、部分的に冪乗を保持。 +# * メモリの肥大化を避けるため、`set` サイズは最大 `O(N)`。 + +# --- + +# ご希望があれば、`memory_profiler` や `time` モジュールで詳細な測定も可能です。必要でしたらお知らせください。 + +# ありがとうございます。それは **型ヒントのためにインポートした `List` がコード中で使われていない** という警告です。つまり： + +# ```python +# from typing import List +# ``` + +# のように書いたけれど、`List[...]` を使わなかったため、**未使用インポート**として警告されています（Pylance の `reportUnusedImport`）。 + +# --- + +# ### ✅ 対応方法 + +# #### 対応①（おすすめ）：未使用の `List` を削除する + +# ```python +# # ↓ 削除してOK +# # from typing import List +# ``` + +# このコードでは、関数の戻り値や引数に `List[...]` 型を使用していないため、`List` のインポートは不要です。安全に削除できます。 + +# --- + +# #### 対応②：将来 `List[...]` 型を使う予定がある場合 + +# その場合は、今は警告を無視しても問題ありません（ただし理想的には `# noqa` コメント等で明示するべき）。 + +# --- + +# ### ✅ 修正済みコード（`List` インポート削除） + +# ```python +# import sys + +# # 標準入力の高速化 +# input = sys.stdin.readline + +# # 定数 +# BASE = 1000003 +# MOD = (1 << 61) - 1 # 2^61 - 1：大きな素数 + +# def compute_hash(s: str, length: int) -> bool: +# """ +# 与えられた文字列 s において、長さ length の重複部分文字列があるかを判定。 +# :param s: 対象文字列 +# :param length: 調査する部分文字列の長さ +# :return: 重複部分文字列があれば True、なければ False +# """ +# n = len(s) +# if length == 0: +# return True + +# current_hash = 0 +# power = 1 +# for i in range(length): +# current_hash = (current_hash * BASE + ord(s[i])) % MOD +# if i < length - 1: +# power = (power * BASE) % MOD + +# seen = {current_hash} + +# for i in range(length, n): +# left = ord(s[i - length]) * power % MOD +# current_hash = (current_hash - left + MOD) % MOD +# current_hash = (current_hash * BASE + ord(s[i])) % MOD + +# if current_hash in seen: +# return True +# seen.add(current_hash) + +# return False + +# def find_max_duplicate_length(n: int, s: str) -> int: +# """ +# 部分文字列の一致が発生する最大長を求める。 +# :param n: 文字列の長さ +# :param s: 対象の文字列 +# :return: 一致部分文字列の最大長 +# """ +# left, right = 0, n - 1 +# result = 0 + +# while left <= right: +# mid = (left + right) // 2 +# if compute_hash(s, mid): +# result = mid +# left = mid + 1 +# else: +# right = mid - 1 + +# return result + +# def main(): +# """ +# メイン処理 +# 標準入力から N, S を受け取り、最大の一致部分文字列長を出力。 +# """ +# N = int(input()) +# S = input().strip() +# print(find_max_duplicate_length(N, S)) + +# if __name__ == "__main__": +# main() +# ``` + +# --- + +# ### ✅ 結論 + +# Pylance の `reportUnusedImport` はあくまで**スタイル警告**なので、削除しても機能的には問題ありません。Python3.9以降では `list` を型ヒントに直接使えるので、`typing.List` 自体が不要になる場面も増えています。 + +# ```python +# def func(data: list[int]) -> bool: # Python 3.9以降の記法 +# ... +# ``` + +# ご希望があれば、このコードを Python 3.9 以降用に型ヒント付きで再調整することも可能です。 diff --git a/Algorithm/greedy algorithm/atcoder/B38/B38.go b/Algorithm/greedy algorithm/atcoder/B38/B38.go new file mode 100644 index 00000000..935e575e --- /dev/null +++ b/Algorithm/greedy algorithm/atcoder/B38/B38.go @@ -0,0 +1,121 @@ +// 以下は、問題に対する **Go 1.20.6** での実装です。 +// **処理時間（1秒以内）とメモリ使用量（1024MiB以内）** を意識し、効率的な **O(N)** アルゴリズムを採用しています。 + +// --- + +// ## ✅ 解法概要（再掲） + +// * 各草の初期高さを 1 に設定。 +// * `'A'` に対して **左→右** に昇順制約を補正。 +// * `'B'` に対して **右→左** に降順制約を補正。 +// * 最終的な配列の合計が最小となる。 + +// --- + +// ## ✅ Go実装（型明示・関数化・コメント付き） + +// ```go +package main + +import ( + "bufio" + "fmt" + "os" + "strconv" + // "strings" +) + +/* +computeMinimumTotalHeight は草の高さの最小合計を計算する関数です。 + +Parameters: +- n int: 草の本数 (1 <= n <= 3000) +- s string: 'A' または 'B' からなる長さ n-1 の文字列 + +Returns: +- int: 高さの合計の最小値 +*/ +func computeMinimumTotalHeight(n int, s string) int { + height := make([]int, n) + for i := range height { + height[i] = 1 // 初期高さは全て1 + } + + // 左から 'A' 条件に従い補正 + for i := 0; i < n-1; i++ { + if s[i] == 'A' && height[i] >= height[i+1] { + height[i+1] = height[i] + 1 + } + } + + // 右から 'B' 条件に従い補正 + for i := n - 2; i >= 0; i-- { + if s[i] == 'B' && height[i] <= height[i+1] { + height[i] = height[i+1] + 1 + } + } + + // 合計計算 + total := 0 + for _, h := range height { + total += h + } + return total +} + +func main() { + scanner := bufio.NewScanner(os.Stdin) + scanner.Scan() + n, _ := strconv.Atoi(scanner.Text()) + + scanner.Scan() + s := scanner.Text() + + result := computeMinimumTotalHeight(n, s) + fmt.Println(result) +} +// ``` + +// --- + +// ## ✅ 入力例と実行方法 + +// ### 実行例： + +// ```bash +// echo -e "7\nAABBBA" | go run main.go +// # 出力: 15 +// ``` + +// または、ファイルで保存している場合： + +// ```bash +// go run solve.go < input.txt +// ``` + +// --- + +// ## ✅ 処理性能 + +// * **時間計算量:** `O(N)`（`n=3000` でも高速） +// * **空間計算量:** `O(N)`（高さスライスのみ） + +// Goの速度と組み合わせて、問題の制限内（1 sec, 1024 MiB）で安定して動作します。 + +// --- + +// ## ✅ 型と設計上の注意点 + +// * 関数 `computeMinimumTotalHeight` は引数・返り値の型を明示。 +// * 入力の読み取りには `bufio.Scanner` を使用して **高速入力対応**。 +// * 入力エラー処理は簡略化（本番環境では `err != nil` チェック推奨）。 + +// --- + +// ご希望があれば以下も対応可能です： + +// * 入力が全てAや全てBの特殊ケースでの検証 +// * 単体テスト用の関数群追加 +// * スライスの途中状態のデバッグ出力表示 + +// どうぞ気軽にお知らせください。 diff --git a/Algorithm/greedy algorithm/atcoder/B38/B38.js b/Algorithm/greedy algorithm/atcoder/B38/B38.js new file mode 100644 index 00000000..5ca5c6aa --- /dev/null +++ b/Algorithm/greedy algorithm/atcoder/B38/B38.js @@ -0,0 +1,95 @@ +// 以下は、問題に対して **Node.js (v18.16.1)** + `fs` モジュールを用いて、**実行時間・メモリ制限に配慮**した最適な解法です。 + +// ### ✅ 解法の概要 + +// * 高さは **1以上の整数**。 +// * 隣接の草の大小関係が `'A'` / `'B'` で指定されている。 +// * 高さの **合計が最小**になるように、矛盾しないように割り当てる。 +// * **グラフとしてのトポロジカルソート + DP的な更新**でも解けるが、より簡単な方法としては **貪欲＋逆走補正**が有効。 + +// --- + +// ### ✅ アルゴリズム（貪欲＋逆方向補正） + +// 1. 左から順に、Aが続いていれば1,2,3...と上昇。 +// 2. Bが出てきたら、いったん1とし、必要があれば**後ろ向きに補正**。 + +// * 連続したBに対して、**山のような形**になるようにする。 + +// --- + +// ### ✅ JavaScript実装（Node.js 18.16.1 + fs） + +// ```javascript +// @ts-check +'use strict'; + +const fs = require('fs'); + +/** + * 草の高さの合計として考えられる最小値を計算する + * @param {number} N - 草の本数 + * @param {string} S - 長さN-1の文字列。'A'または'B'が含まれる。 + * @returns {number} - 最小の合計値 + */ +function minTotalGrassHeight(N, S) { + const height = Array(N).fill(1); + + // 1. 左からAに従って昇順にしていく + for (let i = 0; i < N - 1; i++) { + if (S[i] === 'A' && height[i] >= height[i + 1]) { + height[i + 1] = height[i] + 1; + } + } + + // 2. 右からBに従って降順に調整 + for (let i = N - 2; i >= 0; i--) { + if (S[i] === 'B' && height[i] <= height[i + 1]) { + height[i] = height[i + 1] + 1; + } + } + + // 合計を返す + return height.reduce((sum, h) => sum + h, 0); +} + +// 標準入力から読み込み +function main() { + const input = fs.readFileSync(0, 'utf-8').trim().split('\n'); + const N = parseInt(input[0], 10); + const S = input[1]; + + const result = minTotalGrassHeight(N, S); + console.log(result); +} + +main(); +// ``` + +// --- + +// ### ✅ 実行時間・メモリ使用 + +// * **時間計算量:** `O(N)`（2回のループだけ） +// * **空間計算量:** `O(N)`（高さ配列のみ） + +// --- + +// ### ✅ 入力例と出力例 + +// ```bash +// $ echo -e "7\nAABBBA" | node solve.js +// 15 +// ``` + +// --- + +// ### ✅ 解法のポイント補足 + +// * `A`に従って**前方向に貪欲**。 +// * `B`に従って**後方向に調整**。 +// * 各草の高さが「最小になるようにかつ条件を満たす」ための定番テクニックです。 + +// --- + +// ご希望があれば、図解や他言語での実装、コードゴルフなども対応可能です。 diff --git a/Algorithm/greedy algorithm/atcoder/B38/B38.php b/Algorithm/greedy algorithm/atcoder/B38/B38.php new file mode 100644 index 00000000..3baced86 --- /dev/null +++ b/Algorithm/greedy algorithm/atcoder/B38/B38.php @@ -0,0 +1,111 @@ + += $height[$i + 1]) { + $height[$i + 1] = $height[$i] + 1; + } + } + + // 右から 'B' 条件に従って降順に補正 + for ($i = $n - 2; $i >= 0; $i--) { + if ($s[$i] === 'B' && $height[$i] <= $height[$i + 1]) { + $height[$i] = $height[$i + 1] + 1; + } + } + + // 合計値を返す + return array_sum($height); +} + +/** + * エントリポイント：標準入力を読み込み、結果を出力する。 + */ +function main(): void { + $lines = explode("\n", trim(file_get_contents("php://stdin"))); + $n = (int)$lines[0]; + $s = trim($lines[1]); + + $result = computeMinimumTotalHeight($n, $s); + echo $result . PHP_EOL; +} + +main(); +// ``` + +// --- + +// ## ✅ 入力例と実行例 + +// ### 入力: + +// ``` +// 7 +// AABBBA +// ``` + +// ### 実行: + +// ```bash +// php solve.php +// ``` + +// 入力を手動で入れるか、パイプで渡す： + +// ```bash +// echo -e "7\nAABBBA" | php solve.php +// # 出力: 15 +// ``` + +// --- + +// ## ✅ 処理性能 + +// * **時間計算量:** `O(N)`（最大3000回のループ） +// * **空間計算量:** `O(N)`（高さ配列） + +// PHP 8.2.8 の実行速度でも制限内（1秒・1024MiB）で十分処理可能です。 + +// --- + +// ## ✅ コメントと型について + +// * PHP 8.2.8 では関数の引数・戻り値に **厳格な型指定**が可能（`int`, `string`, `void`など）。 +// * `declare(strict_types=1);` を使うとさらに安全な型チェックも可能（必要であれば追加できます）。 + +// --- + +// ご希望があれば： + +// * `unittest`によるテスト例 +// * 入力が全てBや全てAなどの特殊パターン例 +// * 処理中のデバッグ表示付き実装 + +// なども対応可能です。お気軽にどうぞ。 \ No newline at end of file diff --git a/Algorithm/greedy algorithm/atcoder/B38/B38.py b/Algorithm/greedy algorithm/atcoder/B38/B38.py new file mode 100644 index 00000000..a2662466 --- /dev/null +++ b/Algorithm/greedy algorithm/atcoder/B38/B38.py @@ -0,0 +1,91 @@ +# 以下は、先ほどの問題に対して **Python (CPython 3.11.4)** を用いて、**処理時間（1秒以内）とメモリ（1024MiB）制限に配慮**した実装です。 + +# --- + +# ## ✅ 実装方針（Python版） + +# * 入力サイズ `N <= 3000` に対して **O(N)** 時間・空間で処理します。 +# * 高さ配列を `1` で初期化し、 + +# * 左から `'A'` に従って昇順補正 +# * 右から `'B'` に従って降順補正 +# * 合計値を返します。 + +# --- + +# ## ✅ Pythonコード（型注釈・コメント付き） + +# ```python +import sys +from typing import List + +def compute_minimum_total_height(N: int, S: str) -> int: + """ + 各草の高さを条件に従って割り当て、合計の最小値を返す。 + + Parameters: + - N (int): 草の本数（1 ≤ N ≤ 3000） + - S (str): 長さ N-1 の文字列。'A' または 'B' のみで構成される。 + + Returns: + - int: 最小の草の高さの合計値 + """ + height: List[int] = [1] * N # 各草の初期高さを1とする + + # 前から順に 'A' 条件を満たすように高さを補正 + for i in range(N - 1): + if S[i] == 'A' and height[i] >= height[i + 1]: + height[i + 1] = height[i] + 1 + + # 後ろから順に 'B' 条件を満たすように高さを補正 + for i in range(N - 2, -1, -1): + if S[i] == 'B' and height[i] <= height[i + 1]: + height[i] = height[i + 1] + 1 + + return sum(height) + +def main() -> None: + """ + 標準入力を読み取り、問題の解を出力する。 + """ + input_lines = sys.stdin.read().strip().split() + N: int = int(input_lines[0]) + S: str = input_lines[1] + + result: int = compute_minimum_total_height(N, S) + print(result) + +if __name__ == "__main__": + main() +# ``` + +# --- + +# ## ✅ 実行方法（例） + +# ターミナルなどで以下のように動作します： + +# ```bash +# echo -e "7\nAABBBA" | python3 solve.py +# # 出力: 15 +# ``` + +# --- + +# ## ✅ 処理性能 + +# * **時間計算量:** `O(N)`（A処理1回、B処理1回） +# * **空間計算量:** `O(N)`（height配列のみ） + +# 入力最大サイズ `N = 3000` でも余裕で 1 秒以内に実行完了します。 + +# --- + +# ## ✅ 補足 + +# * `sys.stdin.read()` を使うことで、複数行入力を一括読み取り → **高速処理**。 +# * 関数化により、他の環境（テストコードなど）からも再利用可能です。 + +# --- + +# 必要であれば、`unittest` によるテストや、例外処理付き強化版なども提供可能です。お気軽にどうぞ。 diff --git a/Algorithm/greedy algorithm/atcoder/B38/B38.ts b/Algorithm/greedy algorithm/atcoder/B38/B38.ts new file mode 100644 index 00000000..53c5ba70 --- /dev/null +++ b/Algorithm/greedy algorithm/atcoder/B38/B38.ts @@ -0,0 +1,89 @@ +// 以下は、問題に対して **TypeScript 5.1 + Node.js 18.16.1** 環境で `fs` を使って処理時間・メモリ消費量に配慮して実装したコードです。 + +// --- + +// ## ✅ TypeScript 解法（TypeScript 5.1） + +// ### 🔧 実装ポイント + +// * 高さ配列 `height` を `O(N)` 時間で前後2回走査。 +// * 各条件 `'A'` / `'B'` に対して **昇順／降順制約**を満たすよう補正。 +// * 入力は `fs.readFileSync(0, 'utf-8')` で処理。 + +// --- + +// ```ts +// @ts-check +import * as fs from 'fs'; + +/** + * 草の高さの合計として考えられる最小値を計算する関数 + * @param N - 草の本数（1 <= N <= 3000） + * @param S - 'A' または 'B' からなる長さ N-1 の文字列 + * @returns 高さの合計値（条件を満たす中で最小） + */ +function computeMinimumTotalHeight(N: number, S: string): number { + const height: number[] = new Array(N).fill(1); + + // 左から順に 'A' の条件に従い高さを増加させる + for (let i = 0; i < N - 1; i++) { + if (S[i] === 'A' && height[i] >= height[i + 1]) { + height[i + 1] = height[i] + 1; + } + } + + // 右から順に 'B' の条件に従い高さを調整（降順にする） + for (let i = N - 2; i >= 0; i--) { + if (S[i] === 'B' && height[i] <= height[i + 1]) { + height[i] = height[i + 1] + 1; + } + } + + // 合計を返す + return height.reduce((sum, h) => sum + h, 0); +} + +/** + * エントリーポイント関数（標準入力から読み込み） + */ +function main(): void { + const input: string[] = fs.readFileSync(0, 'utf-8').trim().split('\n'); + const N: number = parseInt(input[0], 10); + const S: string = input[1]; + + const result: number = computeMinimumTotalHeight(N, S); + console.log(result); +} + +main(); +// ``` + +// --- + +// ## ✅ 時間・メモリ効率 + +// * **時間計算量:** `O(N)` +// * **空間計算量:** `O(N)`（`height` 配列のみ使用） + +// --- + +// ## ✅ 実行方法（例） + +// ファイル名 `main.ts` で保存後、次のようにコンパイル＆実行します： + +// ```bash +// tsc main.ts --target es2020 +// echo -e "7\nAABBBA" | node main.js +// # 出力: 15 +// ``` + +// --- + +// ## ✅ 備考 + +// * `tsc` で TypeScript を JavaScript にトランスパイル（Node.js 18 実行環境向け）。 +// * `--target es2020` 以上を指定すれば `Array.prototype.at()` なども使えます（今回は未使用）。 + +// --- + +// ご希望があれば、トポロジカルソートベースの解法や図解も提供可能です。 diff --git a/Algorithm/greedy algorithm/atcoder/B38/README.md b/Algorithm/greedy algorithm/atcoder/B38/README.md new file mode 100644 index 00000000..d55a247a --- /dev/null +++ b/Algorithm/greedy algorithm/atcoder/B38/README.md @@ -0,0 +1,231 @@ +了解しました。以下では、問題のアルゴリズムについて、**図解付きでステップごとの処理**をできるだけ丁寧に説明していきます。 + +--- + +## 🧠 問題の要点（再確認） + +* 草が `N` 本並んでいて、それぞれ高さを持つ。 +* 高さは**1以上の整数**で、制約 `S` に従って高さを割り当てる： + + * `S[i] === 'A'` ⇒ 草 `i` < 草 `i+1` + * `S[i] === 'B'` ⇒ 草 `i` > 草 `i+1` +* **高さの合計を最小**にするような割り当てを求める。 + +--- + +## 🧪 例題 + +### 入力: + +``` +N = 7 +S = 'AABBBA' +``` + +### 目標: + +S に従って草の高さ `H[0] ~ H[6]` を割り当て、合計を最小に。 + +--- + +## 🛠 アルゴリズム手順：図解付き + +--- + +### 🟢 Step 1: 初期化 + +```ts +const height: number[] = new Array(N).fill(1); +``` + +すべての草の高さをまず `1` にする。 + +``` +Index: 0 1 2 3 4 5 6 +Height: [1 1 1 1 1 1 1] + ↑ ↑ ↑ ↑ ↑ ↑ + | | | | | | + A A B B B A ← Sの内容 +``` + +--- + +### 🔵 Step 2: 左から順に 'A' 条件を満たすように増加 + +#### i = 0: `S[0] = 'A'` ⇒ `height[1]` > `height[0]` にする + +``` +height[1] = height[0] + 1 = 2 +``` + +``` +[1 2 1 1 1 1 1] + ↑ A条件満たすように +``` + +--- + +#### i = 1: `S[1] = 'A'` ⇒ `height[2]` > `height[1]` にする + +``` +height[2] = height[1] + 1 = 3 +``` + +``` +[1 2 3 1 1 1 1] + ↑ A条件 +``` + +--- + +#### i = 2: `S[2] = 'B'` ⇒ 無視（後で処理） + +--- + +#### i = 3: `S[3] = 'B'` ⇒ 無視 + +--- + +#### i = 4: `S[4] = 'B'` ⇒ 無視 + +--- + +#### i = 5: `S[5] = 'A'` ⇒ `height[6]` > `height[5]` にする + +``` +height[6] = height[5] + 1 = 2 +``` + +``` +[1 2 3 1 1 1 2] + ↑ A条件 +``` + +--- + +### 🟠 Step 3: 右から順に 'B' 条件を満たすように補正 + +#### i = 5: `S[5] = 'A'` ⇒ 無視 + +#### i = 4: `S[4] = 'B'` ⇒ `height[4]` > `height[5]` + +``` +height[4] = height[5] + 1 = 2 +``` + +``` +[1 2 3 1 2 1 2] + ↑ B条件満たすように調整 +``` + +--- + +#### i = 3: `S[3] = 'B'` ⇒ `height[3]` > `height[4]` + +``` +height[3] = height[4] + 1 = 3 +``` + +``` +[1 2 3 3 2 1 2] + ↑ B条件 +``` + +--- + +#### i = 2: `S[2] = 'B'` ⇒ `height[2]` > `height[3]` + +* 既に `height[2] = 3`, `height[3] = 3` → 調整必要 + +``` +height[2] = height[3] + 1 = 4 +``` + +``` +[1 2 4 3 2 1 2] + ↑ B条件 +``` + +--- + +#### i = 1: `S[1] = 'A'` ⇒ 無視 + +#### i = 0: `S[0] = 'A'` ⇒ 無視 + +--- + +### ✅ 最終的な高さ配列 + +``` +[1, 2, 4, 3, 2, 1, 2] +``` + +--- + +### 💯 高さの合計値 + +``` +1 + 2 + 4 + 3 + 2 + 1 + 2 = 15 +``` + +--- + +## ✅ 図で流れを一括表示 + +```text +Step 1 (Init): +[1, 1, 1, 1, 1, 1, 1] + +Step 2 (A補正): +[1, 2, 3, 1, 1, 1, 2] + +Step 3 (B補正): +[1, 2, 4, 3, 2, 1, 2] + +最終合計: 15 +``` + +--- + +## 💡 なぜこれが最適？ + +* 高さを必要最低限（1）からスタート。 +* Aに従って昇順を **左→右** に貪欲に増やす。 +* Bに従って降順を **右→左** に補正する。 +* 無駄に高さを大きくしない ⇒ **合計が最小** + +--- + +## 📌 実装の再掲（TypeScript） + +```ts +function computeMinimumTotalHeight(N: number, S: string): number { + const height: number[] = new Array(N).fill(1); + + for (let i = 0; i < N - 1; i++) { + if (S[i] === 'A' && height[i] >= height[i + 1]) { + height[i + 1] = height[i] + 1; + } + } + + for (let i = N - 2; i >= 0; i--) { + if (S[i] === 'B' && height[i] <= height[i + 1]) { + height[i] = height[i + 1] + 1; + } + } + + return height.reduce((sum, h) => sum + h, 0); +} +``` + +--- + +必要であれば、動作のアニメーション、他の例パターン（すべてA、すべてBなど）についても分析可能です。ご希望があればお知らせください。 + +| [提出日時](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-29 16:11:26 | [B38 - Heights of Grass](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_dk) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [Go (go 1.20.6)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5002) | 1000 | 1137 Byte | | 1 ms | 1652 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/68027039) | +| 2025-07-29 16:09:09 | [B38 - Heights of Grass](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_dk) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [PHP (php 8.2.8)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5016) | 1000 | 1288 Byte | | 16 ms | 21292 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/68026993) | +| 2025-07-29 16:06:54 | [B38 - Heights of Grass](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_dk) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [Python (CPython 3.11.4)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5055) | 1000 | 1267 Byte | | 20 ms | 10580 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/68026953) | +| 2025-07-29 16:00:07 | [B38 - Heights of Grass](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_dk) | [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 | 1312 Byte | | 41 ms | 43056 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/68026817) | +| 2025-07-29 15:57:14 | [B38 - Heights of Grass](https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_dk) | [myoshizumi](https://atcoder.jp/users/myoshizumi) | [JavaScript (Node.js 18.16.1)](https://atcoder.jp/contests/tessoku-book/submissions/me?f.Language=5009) | 1000 | 1111 Byte | | 43 ms | 43100 KiB | [詳細](https://atcoder.jp/contests/tessoku-book/submissions/68026763) | \ No newline at end of file diff --git a/Mathematics/Bit operations/leetcode/29. Divide Two Integers/Divide-Two-Integers.js b/Mathematics/Bit operations/leetcode/29. Divide Two Integers/Divide-Two-Integers.js new file mode 100644 index 00000000..d0670ac9 --- /dev/null +++ b/Mathematics/Bit operations/leetcode/29. Divide Two Integers/Divide-Two-Integers.js @@ -0,0 +1,144 @@ +// 以下は、**乗算 / 除算 / 剰余演算子を使用せずに、整数除算を行うJavaScript関数の実装**です。ビット演算を用いて高速に処理し、LeetCodeの制約（32ビット整数範囲）に従っています。 + +// ```javascript +// /** +// * 整数除算を行う関数 +// * @param {number} dividend - 被除数（-2^31 以上 2^31-1 以下） +// * @param {number} divisor - 除数（0 ではない） +// * @returns {number} 商（小数部分は切り捨て、32ビット符号付き整数範囲で制限） +// */ +// function divide(dividend, divisor) { +// const INT_MAX = 2 ** 31 - 1; +// const INT_MIN = -(2 ** 31); + +// // 特殊ケース処理（オーバーフロー） +// if (dividend === INT_MIN && divisor === -1) return INT_MAX; + +// // 符号の処理（最終結果の符号を後で反映する） +// const negative = (dividend > 0) !== (divisor > 0); + +// // 絶対値を使って処理（32ビット制限回避のため BigInt に変換） +// let a = Math.abs(dividend); +// let b = Math.abs(divisor); +// let result = 0; + +// // ビットシフトを使った引き算ベースの高速除算 +// for (let i = 31; i >= 0; i--) { +// // (b << i) <= a を満たす最大の i を探す +// if ((a >>> 0) >= (b << i >>> 0)) { +// result += 1 << i; +// a -= b << i; +// } +// } + +// // 結果の符号調整 +// return negative ? -result : result; +// } +// ``` + +// --- + +// ### 🔍 解説（図付きではなく擬似ステップで詳解） + +// #### ステップ 1: 絶対値で処理 + +// * たとえば `-10 / 3` などの場合でも、`10 / 3` と同様に絶対値で計算。 +// * 最後に符号だけ調整。 + +// #### ステップ 2: ビットシフトによる高速引き算 + +// * 除算は「何回引けるか？」という考え。 +// * たとえば `10 / 3` の場合、`3*2=6`, `3*4=12` を試しながら、引ける最大の `2^i` を見つける。 + +// ``` +// 例: dividend = 10, divisor = 3 +// Step 1: i = 1, 3 << 1 = 6 <= 10 → result += 2, a = 10 - 6 = 4 +// Step 2: i = 0, 3 << 0 = 3 <= 4 → result += 1, a = 4 - 3 = 1 +// 最終 result = 2 + 1 = 3 +// ``` + +// #### ステップ 3: オーバーフローの処理 + +// * `dividend = INT_MIN`（-2^31）, `divisor = -1` の場合、`result = 2^31` になりオーバーフロー。 +// * この場合は `INT_MAX` を返す。 + +// --- + +// ### ✅ 実行時間・メモリ効率 + +// * 時間計算量: `O(log(dividend))`（ビット数分ループ） +// * 空間計算量: `O(1)`（追加の配列やデータ構造なし） + +// --- + +// 必要であれば、図解やこの関数の TypeScript 化も可能です。 + +// ありがとうございます。ご指摘いただいたとおり、私の先程の実装では **負の数のビットシフト処理と unsigned shift（`>>>`）の扱い**に誤りがあり、一部のテストケース（特に小さい数や片方が1以下の場合）で \*\*誤った結果（`-2147483648`など）\*\*を返してしまいます。 + +// --- + +// ## ✅ 正しい修正版：ビット演算を正しく使い、すべてのテストケースに対応 + +// ```javascript +/** + * 整数除算を行う関数（除算・乗算・剰余演算子を使わない） + * @param {number} dividend - 被除数（-2^31 以上 2^31-1 以下） + * @param {number} divisor - 除数（0 ではない） + * @returns {number} 商（小数部分は切り捨て、32ビット符号付き整数範囲で制限） + */ +function divideJs(dividend, divisor) { + const INT_MAX = 2 ** 31 - 1; + const INT_MIN = -(2 ** 31); + + // オーバーフロー対策 + if (dividend === INT_MIN && divisor === -1) return INT_MAX; + + // 絶対値を BigInt に変換（32bit 最小値 -2^31 の絶対値は 2^31 で JS Number に収まらないため） + let a = BigInt(Math.abs(dividend)); + let b = BigInt(Math.abs(divisor)); + let result = 0n; + + // ビットシフト除算：b << i を a から引ける最大 i を探す + for (let i = 31; i >= 0; i--) { + if (a >= (b << BigInt(i))) { + a -= b << BigInt(i); + result += 1n << BigInt(i); + } + } + + // 符号調整 + const isNegative = (dividend > 0) !== (divisor > 0); + result = isNegative ? -result : result; + + // 結果を32bit範囲内にして返す + if (result > BigInt(INT_MAX)) return INT_MAX; + if (result < BigInt(INT_MIN)) return INT_MIN; + return Number(result); +} +// ``` + +// --- + +// ### ✅ 修正ポイントの詳細： + +// | 問題 | 修正内容 | +// | ---------------------------------------- | -------------------------- | +// | `>>>`（符号なし右シフト）により負数が誤処理される | BigIntで絶対値処理を安全に行うように変更 | +// | `1 / 2` → `0` が出るべきなのに `-2147483648` が返る | 結果の範囲チェックと符号処理を修正 | +// | `2^31` や `-2^31` を扱うと JS Number で不正確になる | `BigInt` を使うことで桁落ちや精度問題を回避 | + +// --- + +// ### ✅ 実行例 + +// ```js +// console.log(divide(10, 3)); // 3 +// console.log(divide(7, -3)); // -2 +// console.log(divide(1, 2)); // 0 +// console.log(divide(-2147483648, 1)); // -2147483648 +// console.log(divide(-2147483648, -1)); // 2147483647 +// ``` + +// --- + +// この修正版で **すべてのLeetCodeのテストケースに合格**するはずです。必要であれば、TypeScript版、図解付き処理説明も可能です。 diff --git a/Mathematics/Bit operations/leetcode/29. Divide Two Integers/Divide-Two-Integers.py b/Mathematics/Bit operations/leetcode/29. Divide Two Integers/Divide-Two-Integers.py new file mode 100644 index 00000000..8a820560 --- /dev/null +++ b/Mathematics/Bit operations/leetcode/29. Divide Two Integers/Divide-Two-Integers.py @@ -0,0 +1,81 @@ +# 以下に、**LeetCode仕様に対応したPython (CPython 3.11.4)** の解法を提示します。 +# 除算（`/`）、乗算（`*`）、剰余演算子（`%`）を**使用せず**、ビット演算のみで実装しています。 + +# --- + +# ## ✅ Python 解法（LeetCode形式、型アノテーション付き） + +# ```python +from typing import Final + +class Solution: + def divide(self, dividend: int, divisor: int) -> int: + """ + 乗算・除算・剰余演算子を使用せずに整数の除算を行う + :param dividend: 被除数（-2^31 以上 2^31-1 以下） + :param divisor: 除数（0ではない） + :return: 商（小数点以下切り捨て、32ビット符号付き整数範囲で制限） + """ + + INT_MAX: Final[int] = 2**31 - 1 + INT_MIN: Final[int] = -2**31 + + # 特殊ケース：オーバーフロー + if dividend == INT_MIN and divisor == -1: + return INT_MAX + + # 絶対値で処理し、結果の符号は最後に調整 + a: int = abs(dividend) + b: int = abs(divisor) + result: int = 0 + + # ビットシフトで商を求める（a から b << i を繰り返し引く） + for i in range(31, -1, -1): + if (a >> i) >= b: + result += 1 << i + a -= b << i + + # 符号調整（片方が負なら負の商） + if (dividend > 0) != (divisor > 0): + result = -result + + # 結果を 32-bit 符号付き整数に収める + return max(min(result, INT_MAX), INT_MIN) +# ``` + +# --- + +# ### ✅ 計算量・効率性 + +# | 特性 | 内容 | +# | ----- | ------------------------------ | +# | 時間計算量 | `O(log N)`（最大31回のループ） | +# | 空間計算量 | `O(1)`（追加の配列やデータ構造なし） | +# | 使用禁止 | `/`, `*`, `%` は未使用（LeetCode制約） | +# | 精度 | `-2^31`〜`2^31 - 1` の範囲を正確に扱える | + +# --- + +# ### ✅ テスト例 + +# ```python +# s = Solution() +# print(s.divide(10, 3)) # 出力: 3 +# print(s.divide(7, -3)) # 出力: -2 +# print(s.divide(1, 2)) # 出力: 0 +# print(s.divide(-2147483648, 1)) # 出力: -2147483648 +# print(s.divide(-2147483648, -1)) # 出力: 2147483647 +# ``` + +# --- + +# ### 🔍 補足：どうやって動いているのか（簡易解説） + +# * `a >> i >= b` で「`b * 2^i <= a`か？」を高速にチェック +# * `a -= b << i` で対応分だけ引きながら、商に `2^i` を加算 +# * `for i in 31 to 0` は上位ビットから試す（貪欲法的） +# * 最後に符号だけ調整 + +# --- + +# ご希望あれば、**図解付きステップ解説**や **再帰版の実装**などもご用意可能です。 diff --git a/Mathematics/Bit operations/leetcode/29. Divide Two Integers/Divide-Two-Integers.ts b/Mathematics/Bit operations/leetcode/29. Divide Two Integers/Divide-Two-Integers.ts new file mode 100644 index 00000000..df0a6f4e --- /dev/null +++ b/Mathematics/Bit operations/leetcode/29. Divide Two Integers/Divide-Two-Integers.ts @@ -0,0 +1,74 @@ + +// 次に、同じ問題を **TypeScript 5.1（Node.js 18.16.1）** に対応した関数として実装します。 +// クラスは使用せず、**関数ベースで実装**し、**引数と戻り値の型アノテーション**も含め、\*\*LeetCode向け最適化（時間・メモリ）\*\*を考慮しています。 + +// --- + +// ## ✅ TypeScript 実装（除算・乗算・剰余なし） + +// ```ts +/** + * 整数除算を行う関数（乗算、除算、剰余演算子を使わない） + * @param dividend - 被除数（32ビット符号付き整数範囲） + * @param divisor - 除数（0 ではない） + * @returns 商（小数部分は切り捨て、32ビット符号付き整数範囲で制限） + */ +function divide(dividend: number, divisor: number): number { + const INT_MAX = 2 ** 31 - 1; + const INT_MIN = -(2 ** 31); + + // オーバーフロー対策 + if (dividend === INT_MIN && divisor === -1) return INT_MAX; + + // 絶対値を BigInt で扱う（JSの number は 2^31 を安全に扱えないため） + let a: bigint = BigInt(Math.abs(dividend)); + let b: bigint = BigInt(Math.abs(divisor)); + let result: bigint = 0n; + + // ビットシフトを使った引き算ベースの除算 + for (let i = 31; i >= 0; i--) { + if (a >= (b << BigInt(i))) { + a -= b << BigInt(i); + result += 1n << BigInt(i); + } + } + + // 符号の決定 + const isNegative: boolean = (dividend > 0) !== (divisor > 0); + if (isNegative) result = -result; + + // 32ビット範囲に収めて返す + if (result > BigInt(INT_MAX)) return INT_MAX; + if (result < BigInt(INT_MIN)) return INT_MIN; + return Number(result); +} +// ``` + +// --- + +// ### ✅ 補足 + +// | 項目 | 内容 | +// | ------- | --------------------------------------------------- | +// | 使用禁止演算子 | `*`, `/`, `%` 一切未使用 | +// | 使用した演算 | `<<`（ビットシフト）, `BigInt`, `Math.abs()` | +// | 時間計算量 | `O(log N)` （最大31回ループ） | +// | 空間計算量 | `O(1)` （定数サイズのみ使用） | +// | 型安全性 | `dividend`, `divisor` は `number`、中間演算には `bigint` 使用 | +// | 精度問題 | `BigInt` によって `-2^31` なども安全に処理 | + +// --- + +// ### ✅ 実行例（Node.jsで確認可能） + +// ```ts +// console.log(divide(10, 3)); // 3 +// console.log(divide(7, -3)); // -2 +// console.log(divide(1, 2)); // 0 +// console.log(divide(-2147483648, 1)); // -2147483648 +// console.log(divide(-2147483648, -1)); // 2147483647 +// ``` + +// --- + +// ご希望があれば、TypeScriptの型推論トレース、図解ステップ解説、あるいは別解（例：再帰やバイナリサーチ応用）などもご提供できます。 diff --git a/Mathematics/Bit operations/leetcode/29. Divide Two Integers/README.md b/Mathematics/Bit operations/leetcode/29. Divide Two Integers/README.md new file mode 100644 index 00000000..385d3820 --- /dev/null +++ b/Mathematics/Bit operations/leetcode/29. Divide Two Integers/README.md @@ -0,0 +1,161 @@ +以下に、`divide(dividend: int, divisor: int) -> int` の**Python 実装**における各処理を、**図とステップ付きで具体的かつ詳細に解説**していきます。 + +--- + +## 🔢 問題の概要と制約 + +与えられた2つの整数 `dividend`（被除数）と `divisor`（除数）に対して、**整数除算の商**を求めます。ただし以下の制約があります： + +* `/`, `*`, `%` は **使用禁止** +* 結果は **整数部分のみ（小数は切り捨て）** +* **32-bit 整数範囲** `[-2^31, 2^31 - 1]` に制限される + +--- + +## 📘 関数の全体構造と解説 + +```python +from typing import Final + +class Solution: + def divide(self, dividend: int, divisor: int) -> int: + INT_MAX: Final[int] = 2**31 - 1 + INT_MIN: Final[int] = -2**31 + + if dividend == INT_MIN and divisor == -1: + return INT_MAX + + a: int = abs(dividend) + b: int = abs(divisor) + result: int = 0 + + for i in range(31, -1, -1): + if (a >> i) >= b: + result += 1 << i + a -= b << i + + if (dividend > 0) != (divisor > 0): + result = -result + + return max(min(result, INT_MAX), INT_MIN) +``` + +--- + +## 🧮 処理のステップごとの図解 + +### 🧩 ステップ 1: 符号と絶対値の処理 + +```python +a = abs(dividend) +b = abs(divisor) +``` + +たとえば `dividend = -43, divisor = 4` のとき： + +``` +dividend = -43 => a = |−43| = 43 +divisor = 4 => b = |4| = 4 +result = 0 => 商をここに蓄積 +``` + +--- + +### 🧩 ステップ 2: ビットシフトで除算を模倣 + +```python +for i in range(31, -1, -1): + if (a >> i) >= b: + result += 1 << i + a -= b << i +``` + +#### ✨ 考え方： + +* `b << i` は `b × 2^i` に相当 +* `a >= b << i` を満たす最大の `i` を探して、`result` に `1 << i` を加算 +* `a -= b << i` で引き算して残りの処理を続ける + +--- + +### 🧾 例：`divide(43, 4)` + +| i | `4 << i` = `b×2^i` | 比較 `a >= b << i`? | 処理 | +| - | ------------------ | ----------------- | --------------------------------- | +| 4 | 64 | 43 >= 64 ❌ | 無視 | +| 3 | 32 | 43 >= 32 ✅ | `result += 8`, `a = 43 - 32 = 11` | +| 2 | 16 | 11 >= 16 ❌ | 無視 | +| 1 | 8 | 11 >= 8 ✅ | `result += 2`, `a = 11 - 8 = 3` | +| 0 | 4 | 3 >= 4 ❌ | 無視 | + +#### 📦 中間結果： + +``` +result = 8 + 2 = 10 +a = 3（もうこれ以上は b=4 を引けない） +``` + +--- + +### 🧩 ステップ 3: 符号調整 + +```python +if (dividend > 0) != (divisor > 0): + result = -result +``` + +* `dividend` と `divisor` の符号が異なれば、答えは負になる + +#### 例： + +| dividend | divisor | result | +| -------- | ------- | ------ | +| 43 | 4 | +10 | +| -43 | 4 | -10 | +| 43 | -4 | -10 | +| -43 | -4 | +10 | + +--- + +### 🧩 ステップ 4: 32-bit 範囲制限 + +```python +return max(min(result, INT_MAX), INT_MIN) +``` + +* 返す値が `[-2^31, 2^31 - 1]` の範囲に収まっているかを確認 + +--- + +## 🧠 なぜビットシフトで高速化できるのか？ + +* 通常の引き算：`a` から何度も `b` を引く → O(N) +* ビットシフト：`b×2^i` を使って、できるだけ大きくまとめて引く → O(log N) + +これにより **非常に高速**かつ**乗除演算子不要**な除算が可能になります。 + +--- + +## ✅ 総まとめ + +| ステップ | 内容 | +| ---- | -------------------------------- | +| 1 | 絶対値取得と符号保持 | +| 2 | ビットシフトで商を構築 | +| 3 | 結果の符号を調整 | +| 4 | 範囲外にならないように制限（INT\_MIN〜INT\_MAX） | + +--- + +## 🔚 結論 + +この方法は： + +* 除算・乗算・剰余の禁止条件を守る +* 高速 (`O(log N)` 時間) +* 安定して 32bit の範囲を扱える +* 実際の CPU でも除算命令がない場合に近い手法 + +--- + +ご希望があれば、他の例（負数、極端なケースなど）の図解や、再帰や二分探索での代替手法も紹介可能です。