atcoder B09 - Papers 2D差分法 + 累積和

myoshi2891 · myoshi2891 · commit 23fd48bacee9 · 2025-07-05T19:45:16.000+09:00
diff --git a/Mathematics/Accumulation processing (2D difference)/atcoder/B09/B09.go b/Mathematics/Accumulation processing (2D difference)/atcoder/B09/B09.go
@@ -0,0 +1,115 @@
+// 以下は、**Go (Golang)** による高速・省メモリな解法です。
+// **2D差分法 + 累積和**で、1回以上塗られたセルの数（=面積）を求めます。
+
+// ## ✅ 問題の制約と目的
+
+// * 入力：`N ≤ 100000`、各長方形は座標 `(A,B)-(C,D)` の軸に平行な矩形
+// * 範囲：`0 ≤ A_i < C_i ≤ 1500`, `0 ≤ B_i < D_i ≤ 1500`
+// * **出力**：紙が1回以上置かれた2Dグリッド上のマス数（面積）
+
+// ## ✅ Go実装（型明示・メモリ効率重視）
+
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+)
+
+const gridSize int = 1502 // 最大1501に対応するため+1
+
+func main() {
+	reader := bufio.NewReaderSize(os.Stdin, 1<<20)
+	scanner := bufio.NewScanner(reader)
+	scanner.Split(bufio.ScanLines)
+
+	// Read N
+	scanner.Scan()
+	N, _ := strconv.Atoi(scanner.Text())
+
+	// 2D差分グリッド定義（int16で十分）
+	var grid [gridSize][gridSize]int16
+
+	// 入力処理と差分追加（O(N)）
+	for i := 0; i < N; i++ {
+		scanner.Scan()
+		line := scanner.Text()
+		fields := strings.Fields(line)
+		a, _ := strconv.Atoi(fields[0])
+		b, _ := strconv.Atoi(fields[1])
+		c, _ := strconv.Atoi(fields[2])
+		d, _ := strconv.Atoi(fields[3])
+
+		grid[a][b]++
+		grid[c][b]--
+		grid[a][d]--
+		grid[c][d]++
+	}
+
+	// 横方向累積
+	for x := 0; x < gridSize; x++ {
+		for y := 1; y < gridSize; y++ {
+			grid[x][y] += grid[x][y-1]
+		}
+	}
+
+	// 縦方向累積
+	for y := 0; y < gridSize; y++ {
+		for x := 1; x < gridSize; x++ {
+			grid[x][y] += grid[x-1][y]
+		}
+	}
+
+	// 面積（1以上のマスをカウント）
+	area := 0
+	for x := 0; x < 1501; x++ {
+		for y := 0; y < 1501; y++ {
+			if grid[x][y] > 0 {
+				area++
+			}
+		}
+	}
+
+	fmt.Println(area)
+}
+
+// ## ✅ 型とメモリ・時間の見積もり
+
+// | 要素       | 内容                                                   |
+// | -------- | ---------------------------------------------------- |
+// | 配列型      | `var grid [1502][1502]int16`（2バイト×1502×1502 ≈ 4.5MB） |
+// | 時間計算量    | `O(N + H×W)`（最大約 2.3×10⁶）                            |
+// | 実行時間の見込み | 約 100〜200ms（Goの高速処理能力）                               |
+// | メモリ消費    | 約 4.5MB（1024MB 制限の << 1%）                            |
+
+// ---
+
+// ## ✅ 入力例と出力
+
+// **入力**
+
+// ```
+// 2
+// 1 1 3 3
+// 2 2 4 4
+// ```
+
+// **出力**
+
+// ```
+// 7
+// ```
+
+// ## ✅ 解説補足
+
+// * `grid[a][b]++` など、**4点だけ更新**すれば後で累積和を取ることで内部が塗られる。
+// * Goでは固定長配列 `[1502][1502]int16` を使うことでGC負荷を最小化しつつ、定数アクセス可能。
+// * `bufio.Scanner` を使うことで10万件でも高速に読み取り。
+
+// ### 📌 注意点
+
+// * `gridSize = 1502` にしている理由は、最大座標 `1501` に対して `grid[c][d]++` でオーバーしないようにするためです。
+// * 出力は `fmt.Println()` 一発。バッファ不要です。
diff --git a/Mathematics/Accumulation processing (2D difference)/atcoder/B09/B09.js b/Mathematics/Accumulation processing (2D difference)/atcoder/B09/B09.js
@@ -0,0 +1,79 @@
+// この問題は **2D平面上の重なりを考慮した長方形の面積の合計** を求めるものです。
+// 制約より、`x` および `y` 座標は `0 ≤ A_i, B_i < C_i, D_i ≤ 1500` の範囲に収まるため、\*\*1501×1501の2次元グリッドを用いた累積処理（2D差分）\*\*で高速に処理できます。
+
+// ### ✅ 解法方針（2D差分 + 累積和）:
+
+// 1. 長方形 `(A,B)-(C,D)` をグリッド上に差分配列として記録。
+// 2. 最後に累積和を取って、1以上の値が存在するセルをカウント。
+// 3. これにより、重なりを重複カウントせず、正確に面積を求められる。
+
+// ### ✅ JavaScript（Node.js + `fs`）実装:
+const fs = require("fs");
+
+const input = fs.readFileSync("/dev/stdin", "utf8").trim().split("\n");
+const N = parseInt(input[0]);
+const gridSize = 1502; // 0-indexedで最大1501まで扱えるように
+
+// 2D差分用グリッド
+const grid = Array.from({ length: gridSize }, () => new Int16Array(gridSize));
+
+// 差分を記録
+for (let i = 1; i <= N; i++) {
+  const [a, b, c, d] = input[i].split(" ").map(Number);
+  grid[a][b] += 1;
+  grid[c][b] -= 1;
+  grid[a][d] -= 1;
+  grid[c][d] += 1;
+}
+
+// 横方向に累積和
+for (let x = 0; x < gridSize; x++) {
+  for (let y = 1; y < gridSize; y++) {
+    grid[x][y] += grid[x][y - 1];
+  }
+}
+
+// 縦方向に累積和
+for (let y = 0; y < gridSize; y++) {
+  for (let x = 1; x < gridSize; x++) {
+    grid[x][y] += grid[x - 1][y];
+  }
+}
+
+// 面積（1以上のセル数）をカウント
+let area = 0;
+for (let x = 0; x < 1501; x++) {
+  for (let y = 0; y < 1501; y++) {
+    if (grid[x][y] > 0) area++;
+  }
+}
+
+console.log(area);
+
+// ### ✅ 実行時間・メモリ使用量の目安
+
+// * **実行時間**: `O(N + H×W)`（≒ 1e5 + 1500×1500 = 約2.3e6） → 非常に高速
+// * **メモリ**: 約 `1500 x 1500 x 2byte` = 約 4.5MB → メモリ制限 1024MB に対して余裕あり
+
+// ---
+
+// ### ✅ 入力例テスト
+
+// **入力**
+
+// ```
+// 2
+// 1 1 3 3
+// 2 2 4 4
+// ```
+
+// **出力**
+
+// ```
+// 7
+// ```
+
+// ### ✅ ポイント
+
+// * `Int16Array` 使用でメモリ効率向上
+// * 差分更新 → 累積和の2段階処理で高速に重なり面積を正確カウント
diff --git a/Mathematics/Accumulation processing (2D difference)/atcoder/B09/B09.php b/Mathematics/Accumulation processing (2D difference)/atcoder/B09/B09.php
@@ -0,0 +1,93 @@
+<!-- 以下に、\*\*PHP（バージョン8.2以降）\*\*での解法を示します。
+制約：`1 ≤ N ≤ 100000`、座標範囲：`0 ≤ A_i < C_i ≤ 1500`、`0 ≤ B_i < D_i ≤ 1500` --- ## ✅ 解法方針（2D差分法＋累積和） * 各長方形は `(A, B)-(C, D)` の範囲を塗る。 * 差分配列を `4点更新` し、2次元累積和で実際の塗り回数を算出。 * 最後に「1枚以上の紙で覆われた」セルの数をカウント。 --- ## ✅ PHP 実装（型コメント付き） ```php  -->
+<?php
+
+function main(): void {
+    // 入力を取得
+    $input = explode("\n", trim(file_get_contents("php://stdin")));
+    $N = (int)$input[0];
+    $gridSize = 1502; // 境界処理のため+1
+
+    // 2次元配列（grid）を初期化：int型
+    /** @var array<int, array<int, int>> */
+    $grid = array_fill(0, $gridSize, array_fill(0, $gridSize, 0));
+
+    // 差分配列に対して4点更新
+    for ($i = 1; $i <= $N; $i++) {
+        [$a, $b, $c, $d] = array_map('intval', explode(' ', $input[$i]));
+
+        $grid[$a][$b] += 1;
+        $grid[$c][$b] -= 1;
+        $grid[$a][$d] -= 1;
+        $grid[$c][$d] += 1;
+    }
+
+    // 横方向に累積
+    for ($x = 0; $x < $gridSize; $x++) {
+        for ($y = 1; $y < $gridSize; $y++) {
+            $grid[$x][$y] += $grid[$x][$y - 1];
+        }
+    }
+
+    // 縦方向に累積
+    for ($y = 0; $y < $gridSize; $y++) {
+        for ($x = 1; $x < $gridSize; $x++) {
+            $grid[$x][$y] += $grid[$x - 1][$y];
+        }
+    }
+
+    // 1以上のマス（=覆われている面積）をカウント
+    $area = 0;
+    for ($x = 0; $x < 1501; $x++) {
+        for ($y = 0; $y < 1501; $y++) {
+            if ($grid[$x][$y] > 0) {
+                $area++;
+            }
+        }
+    }
+
+    echo $area . "\n";
+}
+
+main();
+
+// ## ✅ 処理時間・メモリ使用量の目安
+
+// | 指標     | 内容                            |
+// | ------ | ----------------------------- |
+// | 時間計算量  | `O(N + H × W)`（H=W=1501）      |
+// | 実行時間   | 約 200～400ms（PHP 8.2, CLI環境）   |
+// | メモリ使用量 | 約 9MB（1502×1502×4バイト = 約9MiB） |
+// | メモリ制限  | ✅ 1024MiB制限以内                 |
+
+// ---
+
+// ## ✅ 入力例と出力
+
+// **入力**
+
+// ```
+// 2
+// 1 1 3 3
+// 2 2 4 4
+// ```
+
+// **出力**
+
+// ```
+// 7
+// ```
+
+// ---
+
+// ## ✅ なぜ差分法か？
+
+// 長方形が `10^5` 枚あっても、**各更新は O(1)** なので全体で `O(N)`
+// → 全体にループしながら塗るより数百倍効率的です。
+
+// ---
+
+// ## 📌 注意点
+
+// * PHPの配列はオブジェクトベースであるため、**`array_fill` を使って初期化**し、未定義アクセスによる `E_WARNING` を防止。
+// * 型ヒントはコメントで明示しました（PHPStan/Larastan等で補完可）。
diff --git a/Mathematics/Accumulation processing (2D difference)/atcoder/B09/B09.py b/Mathematics/Accumulation processing (2D difference)/atcoder/B09/B09.py
@@ -0,0 +1,99 @@
+# 以下に、Python を用いた高速な解法を示します。
+# **型ヒント付き・メモリ効率重視・高速処理**を意識しています。
+
+# ## ✅ 解法：2D差分法 + 累積和（Python版）
+
+# ### 🔍 アプローチの要点
+
+# * **制約**：
+
+#   * 最大 `1500 × 1500` の範囲で、`N ≤ 10⁵`。
+#   * 2次元配列を使って差分更新 → 累積和で正確な重なり面積を高速取得。
+# * **Pythonでの工夫**：
+
+#   * `array` モジュールを使用してメモリ削減（`int16` 型使用）。
+
+# ---
+
+# ### ✅ コード（型付き）
+
+# ```python
+from typing import List
+from array import array
+import sys
+
+def main() -> None:
+    input = sys.stdin.read
+    data = input().split()
+    
+    N: int = int(data[0])
+    grid_size: int = 1502  # 境界対策（最大1501含むため）
+
+    # メモリ効率のため array('h') = signed short（int16）
+    grid: List[array] = [array('h', [0] * grid_size) for _ in range(grid_size)]  # type: ignore
+
+    idx: int = 1
+    for _ in range(N):
+        a: int = int(data[idx])
+        b: int = int(data[idx+1])
+        c: int = int(data[idx+2])
+        d: int = int(data[idx+3])
+        idx += 4
+
+        grid[a][b] += 1
+        grid[c][b] -= 1
+        grid[a][d] -= 1
+        grid[c][d] += 1
+
+    # 横方向累積和
+    for x in range(grid_size):
+        for y in range(1, grid_size):
+            grid[x][y] += grid[x][y - 1]
+
+    # 縦方向累積和
+    for y in range(grid_size):
+        for x in range(1, grid_size):
+            grid[x][y] += grid[x - 1][y]
+
+    # 面積（1枚以上の紙で覆われたセル）をカウント
+    area: int = 0
+    for x in range(1501):
+        for y in range(1501):
+            if grid[x][y] > 0:
+                area += 1
+
+    print(area)
+
+if __name__ == "__main__":
+    main()
+# ```
+
+# ---
+
+# ## 📊 計算量とメモリ
+
+# | 指標      | 値                                 |
+# | ------- | --------------------------------- |
+# | 時間計算量   | `O(N + H × W)`（H=W=1501）          |
+# | 実行時間目安  | 約 200ms ～ 400ms（CPython環境）        |
+# | メモリ使用量  | 約 4.5MB（1502² × 2バイト）             |
+# | 使用データ構造 | `array('h')`（signed short, int16） |
+
+# ---
+
+# ## ✅ 入力例と出力
+
+# **入力**
+
+# ```
+# 2
+# 1 1 3 3
+# 2 2 4 4
+# ```
+
+# **出力**
+
+# ```
+# 7
+# ```
+
diff --git a/Mathematics/Accumulation processing (2D difference)/atcoder/B09/B09.ts b/Mathematics/Accumulation processing (2D difference)/atcoder/B09/B09.ts
diff --git a/Mathematics/Accumulation processing (2D difference)/atcoder/B09/README.md b/Mathematics/Accumulation processing (2D difference)/atcoder/B09/README.md
