Add files using upload-large-folder tool

problems/DP-03/Atcoder/abc207_f/editorial.md

@@ -0,0 +1,28 @@
+# F - Tree Patrolling (editorial)
+
+Source: https://atcoder.jp/contests/abc207/editorial/2162 by en_translator
+
+Transform the given tree into a rooted tree with an arbitrary root, and consider the following DP (Dynamic Programming).
+
+- \(\text{dp}[i][j][k]:=(\)The number of choices of vertices out of the vertices of the subtree rooted at \(i\), such that when takahashi are placed at each of those vertices, there are exactly \(j\) vertices guarded by takahashi, where 
+
+  - \(k = 0\) means that a takahashi is placed at Vertex \(i\),
+  - \(k = 1\) means that no takahashi is placed at Vertex \(i\), and Vertex \(i\) is not guarded by any takahashi, and
+  - \(k = 2\) means that no takahashi is placed at Vertex \(i\), and Vertex \(i\) is guarded by one or more takahashi.\()\)
+
+The DP above naively requires \(O(N^2)\) computations when merging the DPs of subtrees. Since we need to merge them \(N-1\) times, the total computations are \(O(N^3)\), which does not fit in the time limit. However, for the DP of a subtree with \(X\) vertices, we can ignore \(j\) such that \(X \lt j\). Therefore, we can reduce to at most \(O(XY)\) the time required to merge the subtree with \(X\) vertices and the subtree with \(Y\) subtrees.
+
+At a glance it may just seem improving the constant factor, but actually the total computation complexity of \(N-1\) merges has essentially been improved; specifically, it is \(O(N^2)\).
+
+For example, the following precise analysis on complexity is possible:
+
+Prepare an undirected graph \(G\) of \(N\) vertices and \(0\) edges, where Vertex \(i\) on the tree corresponds to the Vertex \(i\) in \(G\).
+
+When merging a subtree \(A\) of \(X\) vertices and a subtree \(B\) of \(Y\) vertices, add an undirected edge from every vertex in \(A\) to every vertex in \(B\). The number of edges added is \(O(XY)\), the computational cost required to merge.
+
+After all merges complete, \(G\) is a complete graph with \(O(N^2)\) number of edges, which is equal to the total sum of computational complexity required for all merge in the DP on tree described above .
+
+Alternatively, one can hold the following two states independently as indices of DP:
+
+- whether or not a takahashi is placed on Vertex \(i\), and
+- whether or not Vertex \(i\) is guarded by one or more takahashi.

problems/DP-03/Atcoder/abc207_f/judge.json

@@ -0,0 +1,15 @@
+{
+  "time_limit_s": 3.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": 30,
+  "note": "no sample/secret split: the statement's samples are among the numbered tests"
+}

problems/DP-03/Atcoder/abc207_f/meta.json

@@ -0,0 +1,16 @@
+{
+  "task_id": "abc207_f",
+  "contest": "abc207",
+  "type": "ABC",
+  "letter": "F",
+  "title": "Tree Patrolling",
+  "url": "https://atcoder.jp/contests/abc207/tasks/abc207_f",
+  "difficulty": 2398,
+  "score": 600,
+  "time_limit_sec": 3.0,
+  "memory_limit_mb": 1024,
+  "n_tests": 30,
+  "editorial_url": "https://atcoder.jp/contests/abc207/editorial/2162",
+  "code_source": "model",
+  "pid": "A1620"
+}

problems/DP-03/Atcoder/abc207_f/solution.cpp

@@ -0,0 +1,68 @@
+// abc207_f: F - Tree Patrolling
+// Written by a model (gpt-6-astra) from the official editorial, https://atcoder.jp/contests/abc207/editorial/2162
+// Judged AC on all 30 tests, max 0.04 s of the 3 s limit (submission 1).
+
+#include <bits/stdc++.h>
+#include <atcoder/modint>
+using namespace std;
+using mint = atcoder::modint1000000007;
+using State = array<mint, 3>;
+
+int main() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int N;
+    cin >> N;
+    vector<vector<int>> graph(N);
+    for (int i = 0; i < N - 1; ++i) {
+        int u, v;
+        cin >> u >> v;
+        --u;
+        --v;
+        graph[u].push_back(v);
+        graph[v].push_back(u);
+    }
+
+    // States: 0 = selected, 1 = unguarded, 2 = guarded but not selected.
+    function<vector<State>(int, int)> dfs = [&](int v, int parent) -> vector<State> {
+        vector<State> dp(2);
+        dp[1][0] = 1;
+        dp[0][1] = 1;
+        int size = 1;
+
+        for (int u : graph[v]) {
+            if (u == parent) continue;
+            vector<State> child = dfs(u, v);
+            int child_size = static_cast<int>(child.size()) - 1;
+            int total = size + child_size;
+            vector<State> next(total + 1);
+
+            for (int i = 0; i <= size; ++i) {
+                const auto &a = dp[i];
+                for (int j = 0; j <= child_size; ++j) {
+                    const auto &b = child[j];
+                    int k = i + j;
+                    next[k][0] += a[0] * (b[0] + b[2]);
+                    next[k][1] += a[1] * (b[1] + b[2]);
+                    next[k][2] += a[2] * (b[0] + b[1] + b[2]);
+                    if (k < total) {
+                        // Selecting v newly guards an unguarded child root.
+                        next[k + 1][0] += a[0] * b[1];
+                        // Selecting the child root newly guards v.
+                        next[k + 1][2] += a[1] * b[0];
+                    }
+                }
+            }
+            dp.swap(next);
+            size = total;
+        }
+        return dp;
+    };
+
+    vector<State> answer = dfs(0, -1);
+    for (int k = 0; k <= N; ++k) {
+        cout << (answer[k][0] + answer[k][1] + answer[k][2]).val() << '\n';
+    }
+    return 0;
+}

problems/DP-03/Atcoder/abc207_f/statement.md

@@ -0,0 +1,109 @@
+# F - Tree Patrolling
+
+**Score**: 600 points
+
+## Problem Statement
+You have a tree with \( N \) vertices, numbered \( 1 \) through \( N \). The \( i \)-th edge connects Vertex \( u_i \) and Vertex \( v_i \).
+
+You will choose some vertices (possibly none) and place a takahashi in each of them to guard the tree. A takahashi placed at Vertex \( x \) will guard \( x \) itself and the vertices directly connected to \( x \) by an edge.
+
+There are \( 2^N \) ways to choose vertices for placing takahashi. In how many of them will there be exactly \( K \) vertices guarded by one or more takahashi?
+
+Find this count and print it modulo \( (10^9 + 7) \) for each \( K = 0, 1, \ldots, N \).
+
+## Constraints
+- \( 1 \leq N \leq 2000 \)
+- \( 1 \leq u_i < v_i \leq N \)
+- The given graph is a tree.
+- All values in input are integers.
+
+## Input
+Input is given from Standard Input in the following format:
+```
+N
+u_1 v_1
+u_2 v_2
+...
+u_{N-1} v_{N-1}
+```
+
+## Output
+Print \( N + 1 \) lines. The \( i \)-th line should contain the answer for \( K = i - 1 \).
+
+---
+
+## Sample Input 1
+```
+3
+1 3
+1 2
+```
+
+## Sample Output 1
+```
+1
+0
+2
+5
+```
+There are eight ways to choose vertices for placing takahashi, as follows:
+- Place a takahashi at no vertices, guarding no vertices.
+- Place a takahashi at Vertex \( 1 \), guarding all vertices.
+- Place a takahashi at Vertex \( 2 \), guarding Vertices \( 1 \) and \( 2 \).
+- Place a takahashi at Vertex \( 3 \), guarding Vertices \( 1 \) and \( 3 \).
+- Place a takahashi at Vertices \( 1 \) and \( 2 \), guarding all vertices.
+- Place a takahashi at Vertices \( 1 \) and \( 3 \), guarding all vertices.
+- Place a takahashi at Vertices \( 2 \) and \( 3 \), guarding all vertices.
+- Place a takahashi at all vertices, guarding all vertices.
+
+---
+
+## Sample Input 2
+```
+5
+1 3
+4 5
+1 5
+2 3
+```
+
+## Sample Output 2
+```
+1
+0
+2
+5
+7
+17
+```
+
+---
+
+## Sample Input 3
+```
+10
+6 10
+1 8
+2 7
+5 6
+3 8
+3 4
+7 10
+4 9
+2 8
+```
+
+## Sample Output 3
+```
+1
+0
+3
+8
+15
+32
+68
+110
+196
+266
+325
+```

problems/DP-03/Atcoder/abc220_f/editorial.md

@@ -0,0 +1,13 @@
+# F - Distance Sums 2 (editorial)
+
+Source: https://atcoder.jp/contests/abc220/editorial/2705 by en_translator
+
+Let us abbreviate \(\sum_{j=1}^{N}dis(i,j)\) to \(ans(i)\).
+
+First, we compute \(dis(1,i)\) for each vertex \(i\). This can be computed with a Depth-First Search (DFS) in a total of \(O(N)\) time, so we can obtain \(ans(1)\).
+
+Next, for a vertex \(s\) adjacent to Vertex \(1\), we consider the difference of \(ans(1)\) and \(ans(s)\). If a vertex \(j\) is included in a subtree under Vertex \(s\), then \(dis(s,j)=dis(i,j)-1\); if not, \(dis(s,j)=dis(i,j)+1\); so the following relation holds:
+
+\(ans(s) = ans(1) + N - 2 \times sub(s)\) (where \(sub(s)\) is the size of subtree under Vertex \(s\))
+
+Therefore, we can precalculate the size of subtree under each vertex and compute \(ans(i)\) from the nearest to Vertex \(1\) to the furthest, so that the problem is solved in a total of \(O(N)\) time.

problems/DP-03/Atcoder/abc220_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": 25,
+  "note": "no sample/secret split: the statement's samples are among the numbered tests"
+}

problems/DP-03/Atcoder/abc220_f/meta.json

@@ -0,0 +1,16 @@
+{
+  "task_id": "abc220_f",
+  "contest": "abc220",
+  "type": "ABC",
+  "letter": "F",
+  "title": "Distance Sums 2",
+  "url": "https://atcoder.jp/contests/abc220/tasks/abc220_f",
+  "difficulty": 1304,
+  "score": 500,
+  "time_limit_sec": 2.0,
+  "memory_limit_mb": 1024,
+  "n_tests": 25,
+  "editorial_url": "https://atcoder.jp/contests/abc220/editorial/2705",
+  "code_source": "editorial",
+  "pid": "A1714"
+}

problems/DP-03/Atcoder/abc220_f/solution.cpp

@@ -0,0 +1,31 @@
+// abc220_f: F - Distance Sums 2
+// Code from the official editorial, https://atcoder.jp/contests/abc220/editorial/2705 (by en_translator)
+// Judged AC on all 25 tests, max 0.39 s of the 2 s limit.
+
+#include <bits/stdc++.h>
+using namespace std;
+
+int main(){
+    int n; cin >> n;
+    vector<vector<int>> g(n);
+    for(int i = 0; i < n - 1; i++) {
+        int a, b; cin >> a >> b;
+        g[a-1].push_back(b-1);
+        g[b-1].push_back(a-1);
+    }
+    vector<long long> sub(n,1), ans(n);
+    function<void(int, int, int)> dfs=[&](int i, int p, int d){
+        ans[0] += d;
+        for(int x : g[i]) if(x != p) {
+            dfs(x, i, d+1);
+            sub[i] += sub[x];
+        }
+    }; dfs(0, -1, 0);
+    function<void(int, int)> dfs2=[&](int i, int p){
+        for(int x : g[i]) if(x != p) {
+            ans[x] = ans[i] - 2 * sub[x] + n;
+            dfs2(x, i);
+        }
+    }; dfs2(0, -1);
+    for(long long x : ans) cout << x << endl;
+}

problems/DP-03/Atcoder/abc220_f/statement.md

@@ -0,0 +1,79 @@
+# F - Distance Sums 2
+
+**Score**: 500 points
+
+## Problem Statement
+Given is a tree with \(N\) vertices. The vertices are numbered \(1, 2, \ldots, N\), and the \(i\)-th edge is an undirected edge connecting Vertices \(u_i\) and \(v_i\).
+
+For each integer \(i\,(1 \leq i \leq N)\), find \(\sum_{j=1}^{N}dis(i,j)\).
+
+Here, \(dis(i,j)\) denotes the minimum number of edges that must be traversed to go from Vertex \(i\) to Vertex \(j\).
+
+## Constraints
+- \(2 \leq N \leq 2 \times 10^5\)
+- \(1 \leq u_i < v_i \leq N\)
+- The given graph is a tree.
+- All values in input are integers.
+
+## Input
+Input is given from Standard Input in the following format:
+```
+N
+u_1 v_1
+u_2 v_2
+...
+u_{N-1} v_{N-1}
+```
+
+## Output
+Print \(N\) lines. The \(i\)-th line should contain \(\sum_{j=1}^{N}dis(i,j)\).
+
+## Sample Input 1
+```
+3
+1 2
+2 3
+```
+
+## Sample Output 1
+```
+3
+2
+3
+```
+We have:
+- \(dis(1,1)+dis(1,2)+dis(1,3)=0+1+2=3\)
+- \(dis(2,1)+dis(2,2)+dis(2,3)=1+0+1=2\)
+- \(dis(3,1)+dis(3,2)+dis(3,3)=2+1+0=3\).
+
+## Sample Input 2
+```
+2
+1 2
+```
+
+## Sample Output 2
+```
+1
+1
+```
+
+## Sample Input 3
+```
+6
+1 6
+1 5
+1 3
+1 4
+1 2
+```
+
+## Sample Output 3
+```
+5
+9
+9
+9
+9
+9
+```

problems/DP-03/Atcoder/abc223_g/data/1.out

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

problems/DP-03/Atcoder/abc223_g/data/10.out

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

problems/DP-03/Atcoder/abc223_g/data/11.out

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

problems/DP-03/Atcoder/abc223_g/data/12.out

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

problems/DP-03/Atcoder/abc223_g/data/13.out

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

problems/DP-03/Atcoder/abc223_g/data/14.out

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

problems/DP-03/Atcoder/abc223_g/data/15.out

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

problems/DP-03/Atcoder/abc223_g/data/16.out

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

problems/DP-03/Atcoder/abc223_g/data/17.out

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

problems/DP-03/Atcoder/abc223_g/data/18.out

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

problems/DP-03/Atcoder/abc223_g/data/19.out

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

problems/DP-03/Atcoder/abc223_g/data/2.in

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

problems/DP-03/Atcoder/abc223_g/data/2.out

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

problems/DP-03/Atcoder/abc223_g/data/20.out

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

problems/DP-03/Atcoder/abc223_g/data/21.out

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

problems/DP-03/Atcoder/abc223_g/data/22.out

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

problems/DP-03/Atcoder/abc223_g/data/23.out

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

problems/DP-03/Atcoder/abc223_g/data/24.out

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

problems/DP-03/Atcoder/abc223_g/data/25.out

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

problems/DP-03/Atcoder/abc223_g/data/26.out

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

problems/DP-03/Atcoder/abc223_g/data/27.out

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