Add files using upload-large-folder tool

problems/PA-03/Atcoder/abc211_f/data/2.in

@@ -0,0 +1,11 @@
+3
+4
+1 2 1 4 3 4 3 2
+4
+2 5 2 3 5 3 5 5
+4
+5 6 5 5 3 5 3 6
+3
+1 4
+2 3
+4 5

problems/PA-03/Atcoder/abc211_f/data/4.out

@@ -0,0 +1,4 @@
+0
+2
+1
+1

problems/PA-03/Atcoder/abc211_f/editorial.md

@@ -0,0 +1,27 @@
+# F - Rectilinear Polygons (editorial)
+
+Source: https://atcoder.jp/contests/abc211/editorial/2333 by en_translator
+
+Hint
+
+ Did you consider \(N = 1\)?
+ Generally, when choosing a solution, it is necessary that it solves the problem with weaker constraints.
+
+Solution
+
+ Let’s first consider \(N=1\).
+ We scan in the increasing order of \(x\) and manage if each \(y\) coordinate is included in the polygon.
+ We only focus on those edges of the polygon parallel to the \(y\) axis, and inspect them in the increasing order of their \(x\) coordinates.
+ For any edge with endpoints \((X, Y_1)\) and \((X, Y_2) (Y_1 \lt Y_2)\), this edge flips the parity of whether or not the segment \([Y_1,Y_2]\) is included in the polygon.
+ Moreover, since the polygon is simple, we can prove that never is it possible that some points of \([Y_1,Y_2]\) is inside the polynomial while some points are outside.
+
+Thus, if an arbitrary point in \([Y_1,Y_2]\) was included in the interior of the polygon, then by the focused edge the entire \([Y_1,Y_2]\) will become outside the polygon.
+ Conversely, if a point in \([Y_1,Y_2]\) was not included in the polygon, then the entire \([Y_1,Y_2]\) will become inside the polygon.
+
+Therefore, if we can process “add \(1\) to a segment”, “add \(-1\) to a segment”, and “get the value of a point” fast, then we can manage whether the points of each \(y\) coordinate is included in the polygon.
+ Such operations can be implemented with a segment tree with lazy propagation (`Lazy Segtree` in ACL).
+
+Now let us consider general \(N\).
+ First, we perform the operations described above for each polygon in order to classify the edges (parallel to the \(y\) axis) into two kinds.
+ In order to answer the question, it is sufficient to manage, for each point of each \(y\) coordinate, how many polygons include the point; this can be accomplished by performing “add \(1\) to a segment”, “add \(-1\) to a segment”, and “get the value of a point” fast, just like before.
+ Hence, we could solve the problem by sorting the off-line queries and the edges (parallel to the \(y\) axis) in the increasing order of \(x\) coordinates.

problems/PA-03/Atcoder/abc211_f/judge.json

@@ -0,0 +1,15 @@
+{
+  "time_limit_s": 2.0,
+  "time_limit_source": "task page",
+  "memory_mb": 1024,
+  "memory_source": "task page",
+  "mode": "exact",
+  "validator_flags": "case_sensitive",
+  "comparison": "token-wise, whitespace-insensitive, case-sensitive (AtCoder's checker)",
+  "validator": null,
+  "tests_dir": "data",
+  "answer_suffix": ".out",
+  "n_sample": null,
+  "n_secret": 40,
+  "note": "no sample/secret split: the statement's samples are among the numbered tests"
+}

problems/PA-03/Atcoder/abc211_f/meta.json

@@ -0,0 +1,16 @@
+{
+  "task_id": "abc211_f",
+  "contest": "abc211",
+  "type": "ABC",
+  "letter": "F",
+  "title": "Rectilinear Polygons",
+  "url": "https://atcoder.jp/contests/abc211/tasks/abc211_f",
+  "difficulty": 2350,
+  "score": 600,
+  "time_limit_sec": 2.0,
+  "memory_limit_mb": 1024,
+  "n_tests": 40,
+  "editorial_url": "https://atcoder.jp/contests/abc211/editorial/2333",
+  "code_source": "model",
+  "pid": "A1644"
+}

problems/PA-03/Atcoder/abc211_f/solution.cpp

@@ -0,0 +1,94 @@
+// abc211_f: F - Rectilinear Polygons
+// Written by a model (gpt-6-astra) from the official editorial, https://atcoder.jp/contests/abc211/editorial/2333
+// Judged AC on all 40 tests, max 0.12 s of the 2 s limit (submission 1).
+
+#include <bits/stdc++.h>
+using namespace std;
+
+struct Fenwick {
+    int n;
+    vector<int> bit;
+    explicit Fenwick(int n) : n(n), bit(n + 1, 0) {}
+    void add(int p, int value) {
+        for (++p; p <= n; p += p & -p) bit[p] += value;
+    }
+    int get(int p) const {
+        int result = 0;
+        for (++p; p > 0; p -= p & -p) result += bit[p];
+        return result;
+    }
+    void range_add(int l, int r, int value) {
+        add(l, value);
+        add(r, -value);
+    }
+};
+
+struct Edge {
+    int x, low, high, delta;
+};
+struct Query {
+    int x, y, id;
+};
+
+int main() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int N;
+    cin >> N;
+    constexpr int SIZE = 100001;
+    Fenwick inside(SIZE);
+    vector<Edge> events;
+    events.reserve(200000);
+
+    auto edge_order = [](const Edge& a, const Edge& b) {
+        if (a.x != b.x) return a.x < b.x;
+        return a.low < b.low;
+    };
+
+    for (int p = 0; p < N; ++p) {
+        int M;
+        cin >> M;
+        vector<Edge> edges;
+        edges.reserve(M / 2);
+        for (int j = 0; j < M; j += 2) {
+            int x1, y1, x2, y2;
+            cin >> x1 >> y1 >> x2 >> y2;
+            edges.push_back({x1, min(y1, y2), max(y1, y2), 0});
+        }
+        sort(edges.begin(), edges.end(), edge_order);
+        for (Edge e : edges) {
+            // Index y represents the height y + 0.5.
+            e.delta = (inside.get(e.low) == 0 ? 1 : -1);
+            inside.range_add(e.low, e.high, e.delta);
+            events.push_back(e);
+        }
+        // After the last edge, all heights are outside this polygon,
+        // so 'inside' is zero and can be reused for the next polygon.
+    }
+
+    int Q;
+    cin >> Q;
+    vector<Query> queries(Q);
+    for (int i = 0; i < Q; ++i) {
+        cin >> queries[i].x >> queries[i].y;
+        queries[i].id = i;
+    }
+    sort(events.begin(), events.end(), edge_order);
+    sort(queries.begin(), queries.end(), [](const Query& a, const Query& b) {
+        return a.x < b.x;
+    });
+
+    Fenwick count(SIZE);
+    vector<int> answer(Q);
+    size_t pos = 0;
+    for (const Query& q : queries) {
+        while (pos < events.size() && events[pos].x <= q.x) {
+            const Edge& e = events[pos++];
+            count.range_add(e.low, e.high, e.delta);
+        }
+        answer[q.id] = count.get(q.y);
+    }
+    for (int value : answer) cout << value << '\n';
+    return 0;
+}

problems/PA-03/Atcoder/abc211_f/statement.md

@@ -0,0 +1,106 @@
+# F - Rectilinear Polygons
+
+**Score:** 600 points
+
+## Problem Statement
+
+We have \(N\) polygons on the \(xy\)-plane.  
+Every side of these polygons is parallel to the \(x\)- or \(y\)-axis, and every interior angle is \(90\) or \(270\) degrees. All of these polygons are simple.  
+The \(i\)-th polygon has \(M_i\) corners, the \(j\)-th of which is \((x_{i, j}, y_{i, j})\).  
+The sides of this polygon are segments connecting the \(j\)-th and \((j+1)\)-th corners. (Assume that \((M_i+1)\)-th corner is the \(1\)-st corner.)
+
+<details>
+<summary>A polygon is simple when...</summary>
+for any two of its sides that are not adjacent, they do not intersect (cross or touch) each other.
+</details>
+
+You are given \(Q\) queries.  
+For each \(i = 1, 2, \dots, Q\), the \(i\)-th query is as follows.
+
+- Among the \(N\) polygons, how many have the point \((X_i + 0.5, Y_i + 0.5)\) inside them?
+
+## Constraints
+
+- \(1 \leq N \leq 10^5\)
+- \(4 \leq M_i \leq 10^5\)
+- Each \(M_i\) is even.
+- \(\sum_i M_i \leq 4 \times 10^5\)
+- \(0 \leq x_{i, j}, y_{i, j} \leq 10^5\)
+- \((x_{i, j}, y_{i, j}) \neq (x_{i, k}, y_{i, k})\) if \(j \neq k\).
+- \(x_{i, j} = x_{i, j+1}\) for \(j = 1, 3, \dots M_i-1\).
+- \(y_{i, j} = y_{i, j+1}\) for \(j = 2, 4, \dots M_i\). (Assume \(y_{i, M_i +1} = y_{i, 1}\).)
+- The given polygons are simple.
+- \(1 \leq Q \leq 10^5\)
+- \(0 \leq X_i, Y_i < 10^5\)
+- All values in input are integers.
+
+## Input
+
+Input is given from Standard Input in the following format:
+
+```
+N
+M_1
+x_{1, 1} y_{1, 1} x_{1, 2} y_{1, 2} ... x_{1, M_1} y_{1, M_1}
+M_2
+x_{2, 1} y_{2, 1} x_{2, 2} y_{2, 2} ... x_{2, M_2} y_{2, M_2}
+...
+M_N
+x_{N, 1} y_{N, 1} x_{N, 2} y_{N, 2} ... x_{N, M_N} y_{N, M_N}
+Q
+X_1 Y_1
+X_2 Y_2
+...
+X_Q Y_Q
+```
+
+## Output
+
+Print \(Q\) lines.  
+The \(i\)-th line should contain the answer to the \(i\)-th query.
+
+## Sample Input 1
+```
+3
+4
+1 2 1 4 3 4 3 2
+4
+2 5 2 3 5 3 5 5
+4
+5 6 5 5 3 5 3 6
+3
+1 4
+2 3
+4 5
+```
+
+## Sample Output 1
+```
+0
+2
+1
+```
+Note that different polygons may cross or touch each other.
+
+## Sample Input 2
+```
+2
+4
+12 3 12 5 0 5 0 3
+12
+1 1 1 9 10 9 10 0 4 0 4 6 6 6 6 2 8 2 8 7 2 7 2 1
+4
+2 6
+4 4
+6 3
+1 8
+```
+
+## Sample Output 2
+```
+0
+2
+1
+1
+```
+Although the polygons are simple, they may not be convex.

problems/PA-03/Atcoder/abc231_f/data/1.in

@@ -0,0 +1,3 @@
+1
+1
+1

problems/PA-03/Atcoder/abc231_f/data/1.out

@@ -0,0 +1 @@
+1

problems/PA-03/Atcoder/abc231_f/data/10.out

@@ -0,0 +1 @@
+858856462

problems/PA-03/Atcoder/abc231_f/data/11.out

@@ -0,0 +1 @@
+4845216277

problems/PA-03/Atcoder/abc231_f/data/12.out

@@ -0,0 +1 @@
+2810211395

problems/PA-03/Atcoder/abc231_f/data/13.out

@@ -0,0 +1 @@
+11096810814

problems/PA-03/Atcoder/abc231_f/data/14.out

@@ -0,0 +1 @@
+976929841

problems/PA-03/Atcoder/abc231_f/data/15.out

@@ -0,0 +1 @@
+4103980557

problems/PA-03/Atcoder/abc231_f/data/16.out

@@ -0,0 +1 @@
+4479565468

problems/PA-03/Atcoder/abc231_f/data/17.out

@@ -0,0 +1 @@
+10006512085

problems/PA-03/Atcoder/abc231_f/data/18.out

@@ -0,0 +1 @@
+5436914470