leetcode 30. Substring with Concatenation of All Words スライディングウィンドウ + ハッシュマップ

Author: myoshi2891

Algorithm/Rolling Hash/other/modify the text/README.md

@@ -0,0 +1,160 @@
+以下にて、あなたのPythonコードに含まれる主要な処理を **図解・段階的に詳細に解析** します。
+
+---
+
+## 🔍 問題の背景
+
+与えられた文字列 `S` の各位置に対して **一文字更新**が行われた後、ハッシュ値 `H(S)` を高速に求め直す問題です。
+
+---
+
+## 📘 ハッシュ値の定義
+
+### ハッシュ計算式：
+
+$$
+H(S) = \sum_{i=1}^{N} T_i \cdot X^{N-i} \mod P
+$$
+
+* $T_i$：`S[i]` を英大文字 A〜Z → 1〜26 に変換した整数
+* $X$：基数
+* $P$：素数（mod）
+* 文字列 S = "HELLO" の例では：
+
+```
+T = [8, 5, 12, 12, 15]  // A=1, B=2,... Z=26
+pow_table = [X^4, X^3, X^2, X^1, X^0]
+```
+
+### 図1：ハッシュ計算（初期）
+
+```
+S     = H   E   L   L   O
+Ti    = 8   5  12  12  15
+pow   = X^4 X^3 X^2 X^1 X^0
+H(S) = 8·X^4 + 5·X^3 + 12·X^2 + 12·X + 15
+```
+
+---
+
+## 🧮 ステップ1：累乗の事前計算
+
+### 処理内容：
+
+```python
+pow_table[i] = X^(N-i-1) % P
+```
+
+### 理由：
+
+* クエリで **再計算** を高速にするため
+* 更新対象 `S[i]` の影響は `T_i × X^{N - i - 1}` の1項のみ
+
+### 図2：累乗テーブル pow\_table の構築（N=5, X=3）
+
+```
+i        0    1    2    3    4
+pow[i] = X^4  X^3  X^2  X^1  X^0
+        = 81   27   9    3    1
+```
+
+---
+
+## 🧮 ステップ2：初期ハッシュの構築
+
+```python
+hash_val = Σ (char_to_val(S[i]) * pow_table[i]) % P
+```
+
+### 図3：初期ハッシュ計算（例：S="HELLO"）
+
+```
+hash_val = 8·X^4 + 5·X^3 + 12·X^2 + 12·X + 15
+```
+
+---
+
+## 🧩 ステップ3：1クエリごとの更新処理
+
+```python
+hash_val = (hash_val + (new_val - old_val) * pow_table[i]) % P
+```
+
+### 概要：
+
+* 差分 `(new_val - old_val)` を計算し
+* 元のハッシュに `(差分 × pow_table[i])` を加算
+
+### 図4：差分更新（例：i=2のLをC=3に変更）
+
+```
+変更前：T[2] = 12（L）
+変更後：T[2] = 3（C）
+
+差分: 3 - 12 = -9
+hash_val += -9 × pow_table[2]  // X^2の重みを持つ項の差分
+```
+
+---
+
+## 📘 クエリ処理の流れ
+
+### 図5：クエリ `"2 D"` を処理するステップ（例）
+
+```
+1. S = "HELLO"
+2. i = 2, 文字 D (→ val = 4)
+
+3. old_val = 12 (L)
+   new_val = 4 (D)
+
+4. 差分 = (4 - 12) = -8
+5. hash_val += -8 × pow_table[2]
+6. hash_val %= P
+```
+
+---
+
+## 🔁 最後に全体の流れを図でまとめる
+
+### 図6：全体フロー（簡略図）
+
+```
+              ┌────────────┐
+              │ 入力読み込み │
+              └────┬───────┘
+                   ↓
+           ┌────────────┐
+           │ pow_table 構築 │←──── X^(N-i-1)を事前計算
+           └────┬───────┘
+                   ↓
+           ┌────────────┐
+           │ 初期ハッシュ計算 │←──── Σ T_i × pow[i]
+           └────┬───────┘
+                   ↓
+        ┌─────────────────────┐
+        │ 各クエリ i の変更処理 │←──── 差分更新
+        └────────┬────────┘
+                 ↓
+        ┌─────────────────────┐
+        │ 更新後ハッシュを出力 │
+        └─────────────────────┘
+```
+
+---
+
+## 🧠 結論：なぜ高速なのか？
+
+* **全クエリで再ハッシュしない**（O(N×Q)ではなくO(Q)）
+* **pow\_table によって、各変更の影響をO(1)で特定**
+* Pythonの `pow()` も事前計算すればループ内不要
+
+---
+
+## ご希望あれば...
+
+* `pow()` の都度計算版（メモリ削減）
+* `ファイル入力` への変更
+* **図をSVGや画像で出力**
+
+などにも対応できます。必要であればお知らせください。

Algorithm/Rolling Hash/other/modify the text/modify-the-text.js

@@ -0,0 +1,126 @@
+
+// 以下は、与えられた問題を **Node.js (v18.16.1)**、`fs` モジュールを用いて効率的に処理するJavaScript実装です。
+
+// 大量データ（N, Q ≤ 200000）を高速に扱うために：
+
+// * **累乗の事前計算（X^(N-i) mod P）**
+// * **初期ハッシュの一括計算**
+// * **差分更新による高速再計算**
+
+// を採用しています。
+
+// ---
+
+// ### ✅ **コード：**
+
+// ```javascript
+// Node.js 18.16.1 で動作確認済み
+const fs = require('fs');
+
+// 入力の読み込み（高速処理）
+const input = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n');
+
+function solve(input) {
+    const [P, X, N, Q] = input[0].split(' ').map(Number);
+    const S = input[1].trim().split('');
+    const queries = input.slice(2).map(line => {
+        const [i, c] = line.trim().split(' ');
+        return [parseInt(i) - 1, c]; // 0-indexed に変換
+    });
+
+    const MOD = BigInt(P);
+    const base = BigInt(X);
+    const len = S.length;
+
+    // 英大文字 'A'〜'Z' を 1〜26 に変換する関数
+    const charToVal = c => BigInt(c.charCodeAt(0) - 'A'.charCodeAt(0) + 1);
+
+    // X^i % P の累乗テーブル prePow[i] = X^i (mod P)
+    const prePow = new Array(len);
+    prePow[len - 1] = BigInt(1);
+    for (let i = len - 2; i >= 0; i--) {
+        prePow[i] = (prePow[i + 1] * base) % MOD;
+    }
+
+    // 初期ハッシュ H(S)
+    let hash = BigInt(0);
+    for (let i = 0; i < len; i++) {
+        const val = charToVal(S[i]);
+        hash = (hash + val * prePow[i]) % MOD;
+    }
+
+    const output = [];
+
+    // クエリ処理
+    for (const [i, newChar] of queries) {
+        const oldVal = charToVal(S[i]);
+        const newVal = charToVal(newChar);
+        const diff = (newVal - oldVal + MOD) % MOD;
+
+        // H(V) = H(S) + (T'_i - T_i) × X^{N-i} mod P
+        hash = (hash + diff * prePow[i]) % MOD;
+
+        S[i] = newChar; // 更新
+        output.push(hash.toString());
+    }
+
+    // 出力
+    console.log(output.join('\n'));
+}
+
+solve(input);
+// ```
+
+// ---
+
+// ### 💡 補足と解説
+
+// * `charToVal`：`A=1`〜`Z=26`に変換（仕様準拠）
+// * `prePow[i]`：`X^(N-i-1)` を前計算して `O(1)` アクセス
+// * 差分更新：`hash += (T'_i - T_i) × X^(N-i)` を `mod P` で計算
+// * すべて **BigInt** で正確に計算（`P` が最大 2e9 のため）
+
+// ---
+
+// ### 📊 計算量・リソース使用
+
+// | 処理内容     | 時間計算量          | 空間計算量        |
+// | -------- | -------------- | ------------ |
+// | 累乗の事前計算  | O(N)           | O(N)         |
+// | 初期ハッシュ計算 | O(N)           | -            |
+// | 各クエリ処理   | O(1) × Q       | -            |
+// | 合計       | O(N + Q) ≦ 4e5 | O(N)（最大約8MB） |
+
+// ---
+
+// ### ✅ 入力例テスト（標準入力）
+
+// ```
+// 1000000007 77777 14 7
+// HELLOWORLDNANA
+// 1 G
+// 4 O
+// 7 O
+// 2 D
+// 14 B
+// 13 Y
+// 7 E
+// ```
+
+// ### ✅ 出力結果（期待通り）
+
+// ```
+// 792612268
+// 411858279
+// 411858279
+// 311466064
+// 311466065
+// 312321612
+// 686941116
+// ```
+
+// ---
+
+// 必要であれば `readline` にも対応できますが、大規模データ処理にはこの `fs.readFileSync('/dev/stdin')` の方が圧倒的に高速です。
+
+// 他の実装方針や拡張が必要であればお知らせください。