Add files using upload-large-folder tool

problems/DP-04/Atcoder/abc176_f/editorial.md

@@ -0,0 +1,27 @@
+# F - Brave CHAIN (editorial)
+
+Source: https://atcoder.jp/contests/abc176/editorial/81 by evima
+
+(Editorial: ynymxiaolongbao)
+
+Among the five cards that is arranged in the \(i\)-th operation, the numbers on the rightmost \(3\) cards are \(A[3i]\), \(A[3i+1]\) and \(A[3i+2]\), which is independent of the operations before the \(i\)-th one. On the other hand, the pair of numbers on the leftmost \(2\) cards is dependent on the operations before the \(i\)-th one.
+
+We use Dynamic Programming (DP).
+
+Let \(DP[i][x][y]\) be the maximum score after the \(i\)-th operation where the leftmost number is \(x\) and the second leftmost number is \(y\).
+
+We assume that, if the third, fourth and fifth number from the left are the same, we always remove those three cards. One can prove by contradiction that this does not lose the optimality. In such case, we can add \(1\) to the answer and regard those \(3\) card as being disappeared.
+
+Among the third, fourth and fifth numbers, if two of them are the same, let \(p\) be the common number, \(q\) the other, and \(k\) be any integer between \(1\) and \(N\) (inclusive), then maximize \(DP[i+1][k][q]\) by \(DP[i][p][k]+1\) or \(DP[i][k][p]+1\) and so on. The time complexity is \(O(N)\).
+
+Among the third, fourth and fifth numbers, let \(p\) be one of them and \(q\) and \(r\) be the other, then maximize \(DP[i+1][q][r]\) by \(DP[i][p][p] + 1\). The time complexity is \(O(1)\).
+
+Let \(p\), \(q\) and \(r\) be the third, fourth and fifth numbers respectively, and \(k\) and \(l\) be any integer between \(1\) and \(N\) (inclusive), then maximize \(DP[i+1][p][q]\), \(DP[i+1][p][r]\) or \(DP[i+1][q][r]\) and others with the maximum value of \(DP[i][k][l]\). This can be processed in an \(O(1)\) time if the maximum value of \(DP[k][l]\) is managed.
+
+Among the third, fourth and fifth numbers, let \(p\) be one of them, and \(k\) and \(l\) be any integer between \(1\) and \(N\) (inclusive), then maximize \(DP[i+1][k][p]\) with the maximum value of \(DP[i][k][l]\) (where only \(l\) is a variable), and maximize \(DP[i+1][l][p]\) by the maximum value of \(DP[i][k][l]\) (where only \(k\) is a variable). If the values above are managed, they can be processed in \(O(N)\) time.
+
+Let \(k\) and \(l\) be any integer between \(1\) and \(N\) (inclusive), then maximize \(DP[i+1][k][l]\) by \(DP[i][k][l]\). However, if you reuse the array and use \(DP[i][k][l]\) as the initial value of \(DP[i+1][k][l]\), you do not need to do this process.
+
+The maximum value can be processed in an \(O(1)\) time each, since the value of DP never decreases.
+
+The time complexity for each \(i\) is \(O(N)\), so the overall time complexity is \(O(N^2)\).

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

problems/DP-04/Atcoder/abc176_f/meta.json

@@ -0,0 +1,16 @@
+{
+  "task_id": "abc176_f",
+  "contest": "abc176",
+  "type": "ABC",
+  "letter": "F",
+  "title": "Brave CHAIN",
+  "url": "https://atcoder.jp/contests/abc176/tasks/abc176_f",
+  "difficulty": 2912,
+  "score": 600,
+  "time_limit_sec": 2.0,
+  "memory_limit_mb": 1024,
+  "n_tests": 55,
+  "editorial_url": "https://atcoder.jp/contests/abc176/editorial/81",
+  "code_source": "model",
+  "pid": "A1434"
+}

problems/DP-04/Atcoder/abc176_f/solution.cpp

@@ -0,0 +1,87 @@
+// abc176_f: F - Brave CHAIN
+// Written by a model (gpt-6-astra) from the official editorial, https://atcoder.jp/contests/abc176/editorial/81
+// Judged AC on all 55 tests, max 0.20 s of the 2 s limit (submission 1).
+
+#include <bits/stdc++.h>
+using namespace std;
+
+struct Update {
+    int x, y, value;
+};
+
+int main() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int N;
+    cin >> N;
+    vector<int> A(3 * N);
+    for (int &x : A) cin >> x;
+
+    const int S = N + 1;
+    vector<int> dp(S * S, -1);
+    vector<int> row_max(S, -1);
+    int best = 0;
+    int bonus = 0;
+
+    auto relax = [&](int x, int y, int value) {
+        if (value <= dp[x * S + y]) return;
+        dp[x * S + y] = value;
+        dp[y * S + x] = value;
+        row_max[x] = max(row_max[x], value);
+        row_max[y] = max(row_max[y], value);
+        best = max(best, value);
+    };
+    relax(A[0], A[1], 0);
+
+    vector<Update> updates;
+    updates.reserve(4 * N + 3);
+
+    for (int round = 0; round < N - 1; ++round) {
+        int pos = 2 + 3 * round;
+        int x = A[pos], y = A[pos + 1], z = A[pos + 2];
+        if (x == y && y == z) {
+            ++bonus;
+            continue;
+        }
+
+        int repeated = -1, other = -1;
+        if (x == y) {
+            repeated = x;
+            other = z;
+        } else if (x == z) {
+            repeated = x;
+            other = y;
+        } else if (y == z) {
+            repeated = y;
+            other = x;
+        }
+
+        // Collect every transition before modifying the previous DP layer.
+        updates.clear();
+        for (int k = 1; k <= N; ++k) {
+            if (row_max[k] >= 0) {
+                updates.push_back({k, x, row_max[k]});
+                updates.push_back({k, y, row_max[k]});
+                updates.push_back({k, z, row_max[k]});
+            }
+            if (repeated != -1) {
+                int value = dp[k * S + repeated];
+                if (value >= 0) {
+                    updates.push_back({k, other, value + 1});
+                }
+            }
+        }
+
+        updates.push_back({x, y, max(best, dp[z * S + z] + 1)});
+        updates.push_back({x, z, max(best, dp[y * S + y] + 1)});
+        updates.push_back({y, z, max(best, dp[x * S + x] + 1)});
+
+        // Retaining the old pair earns zero, so old entries remain valid.
+        for (const auto &u : updates) relax(u.x, u.y, u.value);
+    }
+
+    int last = A.back();
+    cout << bonus + max(best, dp[last * S + last] + 1) << '\n';
+    return 0;
+}

problems/DP-04/Atcoder/abc176_f/statement.md

@@ -0,0 +1,69 @@
+# F - Brave CHAIN
+
+**Score :** 600 points
+
+### Problem Statement
+We have `3N` cards arranged in a row from left to right, where each card has an integer between `1` and `N` (inclusive) written on it. The integer written on the `i`-th card from the left is `A_i`.
+
+You will do the following operation `N-1` times:
+- Rearrange the five leftmost cards in any order you like, then remove the three leftmost cards. If the integers written on those three cards are all equal, you gain `1` point.
+
+After these `N-1` operations, if the integers written on the remaining three cards are all equal, you will gain `1` additional point.
+
+**Find the maximum number of points you can gain.**
+
+### Constraints
+- `1 ≤ N ≤ 2000`
+- `1 ≤ A_i ≤ N`
+
+---
+
+### Input
+Input is given from Standard Input in the following format:
+```
+N
+A_1 A_2 ... A_{3N}
+```
+
+### Output
+Print the maximum number of points you can gain.
+
+---
+
+### Sample Input 1
+```
+2
+1 2 1 2 2 1
+```
+
+### Sample Output 1
+```
+2
+```
+Let us rearrange the five leftmost cards so that the integers written on the six cards will be `2 2 2 1 1 1` from left to right. Then, remove the three leftmost cards, all of which have the same integer `2`, gaining `1` point. Now, the integers written on the remaining cards are `1 1 1`. Since these three cards have the same integer `1`, we gain `1` more point. In this way, we can gain `2` points - which is the maximum possible.
+
+---
+
+### Sample Input 2
+```
+3
+1 1 2 2 3 3 3 2 1
+```
+
+### Sample Output 2
+```
+1
+```
+
+---
+
+### Sample Input 3
+```
+3
+1 1 2 2 2 3 3 3 1
+```
+
+### Sample Output 3
+```
+3
+```

problems/DP-04/Atcoder/abc179_d/editorial.md

@@ -0,0 +1,15 @@
+# D - Leaping Tak (editorial)
+
+Source: https://atcoder.jp/contests/abc179/editorial/133 by evima
+
+First, the naivest solution is a Dynamic Programming (DP) where \(f_i\) := the number of ways to go to Cell \(i\), and check all the possible move for each \(i\), but this needs a time complexity of \(\mathrm{O}(N^2)\).
+
+Let us consider optimizing by making use of the fact that the ways of moving can be written as a sum of small number of segments (\(S = \cup [l_j, r_j]\)). This can be solved either in so-called “distributing DP” or “receiving DP.” This time, we will explain based on distributing DP.
+
+Assume that we have already obtained the values until \(f_i\). When transiting from \(i\), for all \(d \in S\), we want to add \(f_i\) to \(f_{i+d}\).
+
+Here, we want to use the fact that the difference of neighboring values of \(f\) changes at \(O(K)\) positions. Let \(a_i = f_{i} - f_{i-1}\), then this can be optimized by performing the operations of \(a_{i + l_j} := a_{i + l_j} + f_i, a_{i + r_j + 1} := a_{i + r_j + 1} - f_i\) for each \(j\), and then restore \(f\) by \(f_i = f_{i-1} + a_i\).
+
+The total time complexity is \(\mathrm{O}(KN)\).
+
+Note that it is known that this problem can be solved in a total of \(\mathrm{O}(N \log N)\) time even when the transitions cannot be written as a sum of small number of segments.

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

problems/DP-04/Atcoder/abc179_d/meta.json

@@ -0,0 +1,16 @@
+{
+  "task_id": "abc179_d",
+  "contest": "abc179",
+  "type": "ABC",
+  "letter": "D",
+  "title": "Leaping Tak",
+  "url": "https://atcoder.jp/contests/abc179/tasks/abc179_d",
+  "difficulty": 1251,
+  "score": 400,
+  "time_limit_sec": 2.0,
+  "memory_limit_mb": 1024,
+  "n_tests": 28,
+  "editorial_url": "https://atcoder.jp/contests/abc179/editorial/133",
+  "code_source": "model",
+  "pid": "A1450"
+}

problems/DP-04/Atcoder/abc179_d/solution.cpp

@@ -0,0 +1,34 @@
+// abc179_d: D - Leaping Tak
+// Written by a model (gpt-6-astra) from the official editorial, https://atcoder.jp/contests/abc179/editorial/133
+// Judged AC on all 28 tests, max 0.01 s of the 2 s limit (submission 1).
+
+#include <bits/stdc++.h>
+#include <atcoder/modint>
+using namespace std;
+using mint = atcoder::modint998244353;
+
+int main() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int N, K;
+    cin >> N >> K;
+    vector<pair<int, int>> segments(K);
+    for (auto &[l, r] : segments) cin >> l >> r;
+
+    vector<mint> diff(N + 2);
+    diff[1] = 1;
+    diff[2] = -1;
+    mint current = 0;
+
+    for (int i = 1; i <= N; ++i) {
+        current += diff[i];
+        for (auto [l, r] : segments) {
+            if (i + l <= N) diff[i + l] += current;
+            if (i + r + 1 <= N) diff[i + r + 1] -= current;
+        }
+    }
+
+    cout << current.val() << '\n';
+    return 0;
+}

problems/DP-04/Atcoder/abc179_d/statement.md

@@ -0,0 +1,85 @@
+# D - Leaping Tak
+
+**Score:** 400 points
+
+## Problem Statement
+There are \( N \) cells arranged in a row, numbered \( 1, 2, \ldots, N \) from left to right. Tak lives in these cells and is currently on Cell \( 1 \). He is trying to reach Cell \( N \) by using the procedure described below. You are given an integer \( K \) that is less than or equal to \( 10 \), and \( K \) non-intersecting segments \( [L_1, R_1], [L_2, R_2], \ldots, [L_K, R_K] \). Let \( S \) be the union of these \( K \) segments. Here, the segment \( [l, r] \) denotes the set consisting of all integers \( i \) that satisfy \( l \leq i \leq r \).
+
+- When you are on Cell \( i \), pick an integer \( d \) from \( S \) and move to Cell \( i + d \). You cannot move out of the cells.
+
+To help Tak, find the number of ways to go to Cell \( N \), modulo \( 998244353 \).
+
+## Constraints
+- \( 2 \leq N \leq 2 \times 10^5 \)
+- \( 1 \leq K \leq \min(N, 10) \)
+- \( 1 \leq L_i \leq R_i \leq N \)
+- \( [L_i, R_i] \) and \( [L_j, R_j] \) do not intersect (\( i \neq j \))
+- All values in input are integers.
+
+## Input
+Input is given from Standard Input in the following format:
+```
+N K
+L_1 R_1
+L_2 R_2
+:
+L_K R_K
+```
+
+## Output
+Print the number of ways for Tak to go from Cell \( 1 \) to Cell \( N \), modulo \( 998244353 \).
+
+## Sample Input 1
+```
+5 2
+1 1
+3 4
+```
+
+## Sample Output 1
+```
+4
+```
+The set \( S \) is the union of the segment \( [1, 1] \) and the segment \( [3, 4] \), therefore \( S = \{ 1, 3, 4 \} \) holds. There are \( 4 \) possible ways to get to Cell \( 5 \):
+- \( 1 \to 2 \to 3 \to 4 \to 5 \),
+- \( 1 \to 2 \to 5 \),
+- \( 1 \to 4 \to 5 \) and
+- \( 1 \to 5 \).
+
+## Sample Input 2
+```
+5 2
+3 3
+5 5
+```
+
+## Sample Output 2
+```
+0
+```
+Because \( S = \{ 3, 5 \} \) holds, you cannot reach to Cell \( 5 \). Print \( 0 \).
+
+## Sample Input 3
+```
+5 1
+1 2
+```
+
+## Sample Output 3
+```
+5
+```
+
+## Sample Input 4
+```
+60 3
+5 8
+1 3
+10 15
+```
+
+## Sample Output 4
+```
+221823067
+```
+Note that you have to print the answer modulo \( 998244353 \).

problems/DP-04/Atcoder/abc182_f/editorial.md

@@ -0,0 +1,20 @@
+# F - Valid payments (editorial)
+
+Source: https://atcoder.jp/contests/abc182/editorial/327 by evima
+
+Regarding the change as paying negative number of coins, the problem statement can be rephrased as follows:
+
+- Print the number of integer sequences \(x_1, x_2, x_3, \dots, x_N\) such that: 
+
+  - \(-\frac{A_{i + 1}}{A_i} \lt x_i \lt \frac{A_{i + 1}}{A_i} (1 \le i \lt N)\)
+  - \(\sum_{1 \le i \le N} A_ix_i = X\)
+
+If we fix some \(y\), one can uniquely determine the combinations of coins that Lunlun will pay and that clerk returns, thus \(x\) is uniquely determined; conversely, once \(x\) is fixed, \(y\) is also determined, so the paraphrase is valid.
+
+Consider deciding \(x\) one by one in the decreasing order of \(x\). Assume that we have determined \(x_i\). Let \(d = (\sum_{j \ge i} A_jx_j) - X\). (That is, \(d\) is the difference between the balance so far and the target balance \(X\).) Since \(|\sum_{j \lt i} A_jx_j| \lt A_i\), it is necessary that \(|d| \lt A_i\) in order to make \(d = 0\) ultimately. Since \(\sum_{j \ge i} A_jx_j\) is a multiple of \(A_i\), there are at most two integers for \(d\) such that \(|d| \lt A_i\).
+
+With this observation, the following DP is available. dp[\(i\)][\(j\)] : The number of possible combinations of \((x_i, \ldots, x_n)\) such that \(d = j\)
+
+Here, \(j\) can be a large number like \(10^{15}\), but note that for each \(i\) there are at most two \(j\)’s. Therefore, it is good idea to use associated arrays for the second dimension. Transition from dp[\(i\)][\(j\)] depends on the choice of \(x_i\), which is done by considering if it is possible to transition to each of at most two \(j\)’s corresponding to \(i+1\).
+
+Therefore, each transition is done in \(O(1)\) time, and the entire problem can be solved in a total of \(O(N)\) time.

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

problems/DP-04/Atcoder/abc182_f/meta.json

@@ -0,0 +1,16 @@
+{
+  "task_id": "abc182_f",
+  "contest": "abc182",
+  "type": "ABC",
+  "letter": "F",
+  "title": "Valid payments",
+  "url": "https://atcoder.jp/contests/abc182/tasks/abc182_f",
+  "difficulty": 2121,
+  "score": 600,
+  "time_limit_sec": 2.0,
+  "memory_limit_mb": 1024,
+  "n_tests": 35,
+  "editorial_url": "https://atcoder.jp/contests/abc182/editorial/327",
+  "code_source": "model",
+  "pid": "A1470"
+}

problems/DP-04/Atcoder/abc182_f/solution.cpp

@@ -0,0 +1,42 @@
+// abc182_f: F - Valid payments
+// Written by a model (gpt-6-astra) from the official editorial, https://atcoder.jp/contests/abc182/editorial/327
+// Judged AC on all 35 tests, max 0.00 s of the 2 s limit (submission 1).
+
+#include <bits/stdc++.h>
+using namespace std;
+
+int main() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int N;
+    long long X;
+    cin >> N >> X;
+    vector<long long> A(N);
+    for (auto &a : A) cin >> a;
+
+    // States are (balance minus X, number of choices for processed coins).
+    long long rem = X % A.back();
+    vector<pair<long long, long long>> dp = {{-rem, 1}};
+    if (rem != 0) dp.push_back({A.back() - rem, 1});
+
+    for (int i = N - 2; i >= 0; --i) {
+        rem = X % A[i];
+        vector<pair<long long, long long>> next = {{-rem, 0}};
+        if (rem != 0) next.push_back({A[i] - rem, 0});
+
+        long long ratio = A[i + 1] / A[i];
+        for (auto &[new_difference, count] : next) {
+            for (auto [difference, ways] : dp) {
+                long long coins = (new_difference - difference) / A[i];
+                if (-ratio < coins && coins < ratio) {
+                    count += ways;
+                }
+            }
+        }
+        dp = move(next);
+    }
+
+    cout << dp[0].second << '\n';
+    return 0;
+}

problems/DP-04/Atcoder/abc182_f/statement.md

@@ -0,0 +1,96 @@
+# F - Valid payments
+
+**Score :** 600 points
+
+---
+
+## Problem Statement
+
+In Republic of AtCoder, N kinds of coins are used: A₁-yen, A₂-yen, A₃-yen, ..., Aₙ-yen coins.  
+Here, A₁ = 1 holds, and for each i such that 1 ≤ i < N, Aᵢ < Aᵢ₊₁ holds and Aᵢ₊₁ is a multiple of Aᵢ.  
+
+At some shop in this country, Lunlun the dog bought an X-yen product by giving y (≥ X) yen to the clerk and receiving the change of y - X yen from the clerk. (The change may have been 0 yen.)  
+Here, both Lunlun and the clerk used the minimum number of coins needed to represent those amounts of money.  
+Additionally, the clerk did not return any kind of coins that Lunlun gave him.  
+
+Given X, find the number of possible values for y.
+
+---
+
+### Constraints
+- 1 ≤ N ≤ 50
+- 1 = A₁ < A₂ < A₃ < ... < Aₙ ≤ 10¹⁵
+- Aᵢ₊₁ is a multiple of Aᵢ. (1 ≤ i < N)
+- 1 ≤ X ≤ 10¹⁵
+- All values in input are integers.
+
+---
+
+### Input
+Input is given from Standard Input in the following format:
+```
+N X
+A₁ A₂ A₃ ... Aₙ
+```
+
+---
+
+### Output
+Print the number of possible values for y.
+
+---
+
+### Sample Input 1
+```
+3 9
+1 5 10
+```
+
+### Sample Output 1
+```
+3
+```
+y can be 9, 10, or 14.  
+For example, when y = 14, Lunlun gives one 10-yen coin and four 1-yen coins, and the clerk returns one 5-yen coin.  
+Here, the clerk is not returning any kind of coins that Lunlun gives him, satisfying the requirement.
+
+---
+
+### Sample Input 2
+```
+5 198
+1 5 10 50 100
+```
+
+### Sample Output 2
+```
+5
+```
+y can be 198, 200, 203, 208, or 248.
+
+---
+
+### Sample Input 3
+```
+4 44
+1 4 20 100
+```
+
+### Sample Output 3
+```
+4
+```
+y can be 44, 60, 100, or 104.
+
+---
+
+### Sample Input 4
+```
+9 11837029798
+1 942454037 2827362111 19791534777 257289952101 771869856303 3859349281515 30874794252120 216123559764840
+```
+
+### Sample Output 4
+```
+21
+```

problems/DP-04/Atcoder/abc188_f/editorial.md

@@ -0,0 +1,36 @@
+# F - +1-1x2 (editorial)
+
+Source: https://atcoder.jp/contests/abc188/editorial/554 by en_translator
+
+Considering the opposite operations, we have the following equivalent problem:
+
+Find the minimum number of operations of the following three types to change \(Y\) to \(X\):
+
+- Type \(1\) : Add \(1\) to \(Y\)
+- Type \(2\) : Subtract \(1\) from \(Y\)
+- Type \(3\) : Divide \(Y\) by \(2\) (only if \(Y\) is divisible by \(2\))
+
+Here, it is obvious that Type \(1\) and Type \(2\) does not appear consecutively.
+ Also, instead of adding \(1\) \(k (k \ge 2)\) times and then dividing by \(2\), we can add \(1\) \(k-2\) times, divide by \(2\), and then add \(1\) once, so that the number of operations is fewer (and the same applies for subtraction). Thus, we can see that we don’t have to perform Type \(1\) or Type \(2\) consecutively, except for after the last operation of Type \(3\).
+ Conversely, if \(Y = y\) after the last operation of Type \(3\), the number of remaining operations is determined to \(|X - y\).
+
+With the observations above, consider the following recursive function:
+
+\(\mathrm{solve}(y)\) : Answer for \(Y = y\)
+ \(\mathrm{solve}(y) = \)
+
+- If \(y = 1\) : \(|X - y|\)
+- If \(y\) is odd but not \(1\) : \(\min(|X - y|, \mathrm{solve}(\frac{y + 1}{2}) + 2, \mathrm{solve}(\frac{y - 1}{2}) + 2)\)
+- If \(y\) is even : \(\min(|X - y|, \mathrm{solve}(\frac{y}{2}) + 1)\)
+
+Memorize this by \(y\) and call \(\mathrm{solve}(Y)\), and we obtain the answer.
+
+Now let’s consider the time complexity.
+ Consider the number of \(y\) in \(\mathrm{solve}(y)\) that originates from \(\mathrm{solve}(Y)\).
+ If we regard the execution of \(\mathrm{solve}(Y)\) as Level-\(0\) recursion, then \(y\) in Level-\(d\) recursion satisfies:
+
+- \(y \ge \frac{\frac{\frac{Y - 1}{2} - 1}{2} - 1}{2}_\ddots\) (\(d\) fractions) \( = \frac{Y}{2^d} - \sum_{i = 1}^d \frac{1}{2^d} \gt \frac{Y}{2^d} - 1\) (If the recursion is repeated with \(\mathrm{solve}(\frac{y - 1}{2})\))
+- \(y \le \frac{\frac{\frac{Y + 1}{2} + 1}{2} + 1}{2}_\ddots\) (\(d\) fractions) \( = \frac{Y}{2^d} + \sum_{i = 1}^d \frac{1}{2^d} \lt \frac{Y}{2^d} + 1\) (If the recursion is repeated with \(\mathrm{solve}(\frac{y + 1}{2})\))
+
+Therefore, for each level, at most \(2\) (constant) kinds of \(y\) is called.
+ Since there are no more than \(O(\log(Y))\) levels, the total time complexity is \(O(\log(Y))\) if we use an \(O(1)\) hash map.

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

problems/DP-04/Atcoder/abc188_f/meta.json

@@ -0,0 +1,16 @@
+{
+  "task_id": "abc188_f",
+  "contest": "abc188",
+  "type": "ABC",
+  "letter": "F",
+  "title": "+1-1x2",
+  "url": "https://atcoder.jp/contests/abc188/tasks/abc188_f",
+  "difficulty": 1865,
+  "score": 600,
+  "time_limit_sec": 2.0,
+  "memory_limit_mb": 1024,
+  "n_tests": 50,
+  "editorial_url": "https://atcoder.jp/contests/abc188/editorial/554",
+  "code_source": "model",
+  "pid": "A1506"
+}

problems/DP-04/Atcoder/abc188_f/solution.cpp

@@ -0,0 +1,37 @@
+// abc188_f: F - +1-1x2
+// Written by a model (gpt-6-astra) from the official editorial, https://atcoder.jp/contests/abc188/editorial/554
+// Judged AC on all 50 tests, max 0.00 s of the 2 s limit (submission 1).
+
+#include <bits/stdc++.h>
+using namespace std;
+
+using int64 = long long;
+int64 X;
+unordered_map<int64, int64> memo;
+
+int64 solve(int64 y) {
+    if (y == 1) return X - 1;
+    auto it = memo.find(y);
+    if (it != memo.end()) return it->second;
+
+    int64 answer = llabs(X - y);
+    if (y % 2 == 0) {
+        answer = min(answer, solve(y / 2) + 1);
+    } else {
+        answer = min(answer, solve((y - 1) / 2) + 2);
+        answer = min(answer, solve((y + 1) / 2) + 2);
+    }
+    memo[y] = answer;
+    return answer;
+}
+
+int main() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int64 Y;
+    cin >> X >> Y;
+    memo.reserve(256);
+    cout << solve(Y) << '\n';
+    return 0;
+}

problems/DP-04/Atcoder/abc188_f/statement.md

@@ -0,0 +1,73 @@
+# F - +1-1x2
+
+**Score**: `600` points
+
+## Problem Statement
+Takahashi has written an integer `X` on a blackboard.  
+He can do the following three kinds of operations any number of times in any order:
+- increase the value written on the blackboard by `1`;
+- decrease the value written on the blackboard by `1`;
+- multiply the value written on the blackboard by `2`.
+
+Find the minimum number of operations required to have `Y` written on the blackboard.
+
+### Constraints
+- `1 ≤ X ≤ 10^18`
+- `1 ≤ Y ≤ 10^18`
+- `X` and `Y` are integers.
+
+---
+
+### Input
+Input is given from Standard Input in the following format:
+```
+X Y
+```
+
+### Output
+Print the answer.
+
+---
+
+### Sample Input 1
+```
+3 9
+```
+
+### Sample Output 1
+```
+3
+```
+Initially, `3` is written on the blackboard. The following three operations can make it `9`:
+- increase the value by `1`, which results in `4`;
+- multiply the value by `2`, which results in `8`;
+- increase the value by `1`, which results in `9`.
+
+---
+
+### Sample Input 2
+```
+7 11
+```
+
+### Sample Output 2
+```
+3
+```
+The following procedure can make the value on the blackboard `11`:
+- decrease the value by `1`, which results in `6`;
+- multiply the value by `2`, which results in `12`;
+- decrease the value by `1`, which results in `11`.
+
+---
+
+### Sample Input 3
+```
+1000000000000000000 1000000000000000000
+```
+
+### Sample Output 3
+```
+0
+```
+If the value initially written on the blackboard equals `Y`, print `0`.

problems/DP-04/Atcoder/abc199_f/editorial.md

@@ -0,0 +1,15 @@
+# F - Graph Smoothing (editorial)
+
+Source: https://atcoder.jp/contests/abc199/editorial/1171 by en_translator
+
+Let \(y_i\) be the expected value of the number written on vertex \(i\) after a single operation, before which each vertex \(i\) has \(x_i\) written on it.
+
+Then, there exist an matrix \(m\) such that \(xm = y\), or equivalently \(\displaystyle y_i = \sum_{j = 1}^N x_j m_{j, i}\).
+ Specifically, \(m\) can be constructed as follows.
+
+- Initially each element of \(m\) is \(0\)
+- Consider each vertex \(i\). Let \(d_i\) be the degree of vertex \(i\) and \(a_{i, 1}, a_{i, 2}, \dots, a_{i, d_i}\) be the adjacent vertices.
+- At the probability of \(\frac{d_i}{M}\), an edge adjacent to vertex \(i\) is chosen. In such case the contribution of \(x_i\) to \(y_i\) decreases from \(1\) to \(\frac{1}{2}\), so \(m_{i, i} = 1 - \frac{d_i}{M} \times \frac{1}{2}\).
+- Also, when an edge connecting \(a_{i, j}\) and \(i\) is chosen (at the probability of \(\frac{1}{M}\), \(x_{a_{i, j}}\) contribute to \(y_i\) at the ratio of \(\frac{1}{2}\), so we let \(m_{a_{i, j}, i} = \frac{1}{2M}\).
+
+Since the answer for the problem is \(Am^K\), we can calculate \(m^K\) with fast exponentiation so that the problem is solved in a total of \(O(N^3 \log(K))\) time.

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

problems/DP-04/Atcoder/abc199_f/meta.json

@@ -0,0 +1,16 @@
+{
+  "task_id": "abc199_f",
+  "contest": "abc199",
+  "type": "ABC",
+  "letter": "F",
+  "title": "Graph Smoothing",
+  "url": "https://atcoder.jp/contests/abc199/tasks/abc199_f",
+  "difficulty": 2065,
+  "score": 600,
+  "time_limit_sec": 2.0,
+  "memory_limit_mb": 1024,
+  "n_tests": 29,
+  "editorial_url": "https://atcoder.jp/contests/abc199/editorial/1171",
+  "code_source": "model",
+  "pid": "A1572"
+}

problems/DP-04/Atcoder/abc199_f/solution.cpp

@@ -0,0 +1,73 @@
+// abc199_f: F - Graph Smoothing
+// Written by a model (gpt-6-astra) from the official editorial, https://atcoder.jp/contests/abc199/editorial/1171
+// Judged AC on all 29 tests, max 0.04 s of the 2 s limit (submission 1).
+
+#include <bits/stdc++.h>
+#include <atcoder/modint>
+using namespace std;
+using mint = atcoder::modint1000000007;
+using Matrix = vector<vector<mint>>;
+
+Matrix multiply(const Matrix& a, const Matrix& b) {
+    int n = (int)a.size();
+    Matrix c(n, vector<mint>(n));
+    for (int i = 0; i < n; ++i) {
+        for (int k = 0; k < n; ++k) {
+            mint v = a[i][k];
+            if (v.val() == 0) continue;
+            for (int j = 0; j < n; ++j) {
+                c[i][j] += v * b[k][j];
+            }
+        }
+    }
+    return c;
+}
+
+vector<mint> multiply(const vector<mint>& a, const Matrix& b) {
+    int n = (int)a.size();
+    vector<mint> c(n);
+    for (int i = 0; i < n; ++i) {
+        for (int j = 0; j < n; ++j) {
+            c[j] += a[i] * b[i][j];
+        }
+    }
+    return c;
+}
+
+int main() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n, m;
+    long long k;
+    cin >> n >> m >> k;
+    vector<mint> a(n);
+    for (int i = 0; i < n; ++i) {
+        int x;
+        cin >> x;
+        a[i] = x;
+    }
+
+    Matrix transition(n, vector<mint>(n));
+    for (int i = 0; i < n; ++i) transition[i][i] = 1;
+    mint probability = mint(2 * m).inv();
+    for (int i = 0; i < m; ++i) {
+        int x, y;
+        cin >> x >> y;
+        --x;
+        --y;
+        transition[x][x] -= probability;
+        transition[y][y] -= probability;
+        transition[x][y] += probability;
+        transition[y][x] += probability;
+    }
+
+    while (k > 0) {
+        if (k & 1) a = multiply(a, transition);
+        k >>= 1;
+        if (k > 0) transition = multiply(transition, transition);
+    }
+
+    for (mint x : a) cout << x.val() << '\n';
+    return 0;
+}

problems/DP-04/Atcoder/abc199_f/statement.md

@@ -0,0 +1,103 @@
+# F - Graph Smoothing
+
+**Score**: 600 points
+
+## Problem Statement
+We have a simple undirected graph with \(N\) vertices and \(M\) edges. The vertices are numbered \(1\) through \(N\) and the edges are numbered \(1\) through \(M\).  
+Edge \(i\) connects Vertex \(X_i\) and Vertex \(Y_i\). Initially, Vertex \(i\) has an integer \(A_i\) written on it.  
+You will do the following operation \(K\) times:
+- Choose one from the \(M\) edges uniformly at random and independently from other choices. Let \(x\) be the arithmetic mean of the numbers written on the two vertices connected by that edge. Replace each number written on those vertices with \(x\).
+
+For each vertex \(i\), find the expected value of the number written on that vertex after \(K\) operations, and print it modulo \((10^9 + 7)\) as described in Notes.
+
+## Notes
+When printing a rational number, first, represent it as a fraction \(\frac{y}{x}\), where \(x\) and \(y\) are integers and \(x\) is not divisible by \((10^9+7)\) (under the Constraints of this problem, such a representation is always possible).  
+Then, print the only integer \(z\) between \(0\) and \((10^9+6)\) (inclusive) such that \(xz \equiv y \pmod {10^9+7}\).
+
+## Constraints
+- \(2 \le N \le 100\)
+- \(1 \le M \le \frac{N(N - 1)}{2}\)
+- \(0 \le K \le 10^9\)
+- \(0 \le A_i \le 10^9\)
+- \(1 \le X_i \le N\)
+- \(1 \le Y_i \le N\)
+- The given graph is simple.
+- All values in input are integers.
+
+---
+
+## Input
+Input is given from Standard Input in the following format:
+```
+N M K
+A_1 A_2 A_3 ... A_N
+X_1 Y_1
+X_2 Y_2
+X_3 Y_3
+...
+X_M Y_M
+```
+
+## Output
+Print \(N\) lines.  
+The \(i\)-th line should contain the expected value of the number written on that vertex after \(K\) operations, modulo \((10^9 + 7)\), as described in Notes.
+
+---
+
+## Sample Input 1
+```
+3 2 1
+3 1 5
+1 2
+1 3
+```
+
+## Sample Output 1
+```
+3
+500000005
+500000008
+```
+- If Edge \(1\) is chosen in the only operation: the vertices written on Vertices \(1, 2, 3\) will be \(2, 2, 5\), respectively.
+- If Edge \(2\) is chosen in the only operation: the vertices written on Vertices \(1, 2, 3\) will be \(4, 1, 4\), respectively.
+  
+Thus, the expected values of the numbers written on Vertices \(1, 2, 3\) are \(3, \frac{3}{2}, \frac{9}{2}\), respectively.  
+If we express them modulo \((10^9 + 7)\) as described in Notes, they will be \(3, 500000005, 500000008\), respectively.
+
+---
+
+## Sample Input 2
+```
+3 2 2
+12 48 36
+1 2
+1 3
+```
+
+## Sample Output 2
+```
+750000036
+36
+250000031
+```
+
+---
+
+## Sample Input 3
+```
+4 5 1000
+578 173 489 910
+1 2
+2 3
+3 4
+4 1
+1 3
+```
+
+## Sample Output 3
+```
+201113830
+45921509
+67803140
+685163678
+```

problems/DP-04/Atcoder/abc200_e/editorial.md

@@ -0,0 +1,16 @@
+# E - Patisserie ABC 2 (editorial)
+
+Source: https://atcoder.jp/contests/abc200/editorial/1548 by en_translator
+
+There are many ways of solving this problem. We will introduce one of them.
+
+First, let \(X\) be the sum of beauty, taste, and popularity, and for each integer from \(3\) through \(3N\) (inclusive), let us find the number of cakes where \(X = k\).
+ This number corresponds to the number of ways of choosing an integer from \(\{1,2, \dots , N\}\) three times whose sum is \(k\).
+ This problem can be solved by the DP (Dynamic Programming) where dp[the number of integers chosen][their sum]=[the number of such choices]. A naive implementation will need a total of \(O(N^2)\) time, but since the destination of a transition from \(dp[i][j]\) is a segment of \(dp[i+1][j+1],dp[i+1][j+2], \dots dp[i+1][j+N]\), so one can speed this up to \(O(N)\) with cumulative sums.
+
+Now we figured out the value \(X\) of the \(K\)-th cake from the left. Then, the problem can be solved in an \(O(N)\) loop, iterating each “beauty” of the cake.
+ Specifically, once we know the “beauty” and the value \(X\) of a cake, the possible range of “taste” forms a single segment, so each iteration of the loop will find such segment. For more details, refer to the sample code as well.
+
+Therefore, the problem has been solved in a total of \(O(N)\) time.
+
+BONUS! This problem can be solved for little more large constraints, and the problem with many queries of cakes can also be solved. Do consider many ways to solve!

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

problems/DP-04/Atcoder/abc200_e/meta.json

@@ -0,0 +1,16 @@
+{
+  "task_id": "abc200_e",
+  "contest": "abc200",
+  "type": "ABC",
+  "letter": "E",
+  "title": "Patisserie ABC 2",
+  "url": "https://atcoder.jp/contests/abc200/tasks/abc200_e",
+  "difficulty": 1955,
+  "score": 500,
+  "time_limit_sec": 2.0,
+  "memory_limit_mb": 1024,
+  "n_tests": 77,
+  "editorial_url": "https://atcoder.jp/contests/abc200/editorial/1548",
+  "code_source": "editorial",
+  "pid": "A1577"
+}

problems/DP-04/Atcoder/abc200_e/solution.cpp

@@ -0,0 +1,40 @@
+// abc200_e: E - Patisserie ABC 2
+// Code from the official editorial, https://atcoder.jp/contests/abc200/editorial/1548 (by en_translator)
+// Judged AC on all 77 tests, max 0.03 s of the 2 s limit.
+
+#include<bits/stdc++.h>
+
+using namespace std;
+
+int main(){
+  int n;
+  long long k;
+  cin >> n >> k;
+  long long dp[4][3000005]={0};
+  dp[0][0]=1;
+  for(int i=0;i<3;i++){
+    for(int j=0;j<=i*n;j++){
+      dp[i+1][j+1]+=dp[i][j];
+      dp[i+1][j+n+1]-=dp[i][j];
+    }
+    for(int j=1;j<=(i+1)*n;j++){
+      dp[i+1][j]+=dp[i+1][j-1];
+    }
+  }
+  
+  int x;
+  for(int i=3;i<=3*n;i++){
+    if(k<=dp[3][i]){x=i;break;}
+    else{k-=dp[3][i];}
+  }
+  for(int i=1;i<=n;i++){
+    int jmi=max(1,x-i-n);
+    int jma=min(n,x-i-1);
+    if(jmi>jma){continue;}
+    if(k>(jma-jmi+1)){k-=(jma-jmi+1);continue;}
+    int y=jmi+k-1;
+    int z=x-i-y;
+    cout << i << ' ' << y << ' ' << z << '\n';
+    return 0;
+  }
+}

problems/DP-04/Atcoder/abc200_e/statement.md

@@ -0,0 +1,66 @@
+# E - Patisserie ABC 2
+
+**Score:** 500 points
+
+## Problem Statement
+Takahashi, a pastry chef at *ABC Confiserie*, has decided to make cakes to celebrate AtCoder Beginner Contest 200.
+
+A cake made by Takahashi has three parameters: *beauty*, *taste*, and *popularity*, each of which is represented by an integer between `1` and `N` (inclusive).
+
+He has made a cake of beauty `i`, taste `j`, and popularity `k` for every triple `(i,j,k) (1 ≤ i,j,k ≤ N)`.  
+Then, he has arranged these `N^3` cakes in a row, as follows:
+- The cakes are in ascending order of the sum of beauty, taste, and popularity from left to right.
+- For two cakes with the same sum of beauty, taste, and popularity, the cake with the smaller beauty is to the left.
+- For two cakes with the same sum and the same beauty, the cake with the smaller taste is to the left.
+
+Find the beauty, taste, and popularity of the `K`-th cake from the left.
+
+## Constraints
+- All values in input are integers.
+- `1 ≤ N ≤ 10^6`
+- `1 ≤ K ≤ N^3`
+
+## Input
+Input is given from Standard Input in the following format:
+```
+N K
+```
+
+## Output
+Print three integers representing the cake's beauty, taste, popularity, in this order, with spaces in between.
+
+## Sample Input 1
+```
+2 5
+```
+
+## Sample Output 1
+```
+1 2 2
+```
+The cakes are in the following order:
+```
+(1,1,1),(1,1,2),(1,2,1),(2,1,1),(1,2,2),(2,1,2),(2,2,1),(2,2,2).
+```
+Here, each triple of integers represents the beauty, taste, and popularity of a cake.
+
+## Sample Input 2
+```
+1000000 1000000000000000000
+```
+
+## Sample Output 2
+```
+1000000 1000000 1000000
+```
+The values in input may be large.
+
+## Sample Input 3
+```
+9 47
+```
+
+## Sample Output 3
+```
+3 1 4
+```

problems/DP-04/Atcoder/abc201_f/editorial.md

@@ -0,0 +1,32 @@
+# F - Insertion Sort (editorial)
+
+Source: https://atcoder.jp/contests/abc201/editorial/1838 by en_translator
+
+First of all, each person has to be moved at most once. So, this problem is equivalent to the task of assigning each person the four statuses of either moving to the left end / moving to the right end / moving arbitrarily / never let them move. We will approach the problem with this premise.
+
+First, let us fix an ordered set \(S=(S_1,S_2,\ldots,S_k)\) of people that will never be moved. Here, we assume \(S_1 \lt S_2 \lt \cdots \lt S_k\). Then we can see that:
+
+- Let \(\text{pos}[i]\) be the initial position of the person \(i\) counted from the left. Then, it should hold that \(\text{pos}[S_1] \lt \text{pos}[S_2] \lt \cdots \lt \text{pos}[S_k]\).
+
+Since every person in \(S\) does not move, it is obvious.
+
+With more observation we can see the following three facts:
+
+- Each person \(i\) such that \(S_1 \lt i \lt S_k\), \(i \notin S\) should be assigned the operation of being moved to an arbitrary position, paying cost \(A_i\).
+- Each person \(i\) such that \(i \lt S_1\) can be assigned either operation of being moved to an arbitrary position with cost \(A_i\) or being moved to the left end with cost \(B_i\).
+- Each person \(i\) such that \(S_k \lt i\) can be assigned either operation of being moved an arbitrary position with cost \(A_i\) or being moved to the right end with cost \(C_i\).
+
+Based on these observations, we will perform a DP (Dynamic Programming) where \(\text{dp}[i]:=(\)the minimum sum of costs required to sort the people with indices less than or equal to \(i\), such that the maximum index of person in \(S\) is \(i)\). The transitions are as follows:
+
+\[ dp[i]:=\min(\sum_{j=1}^{i-1}\min(A_j,B_j),\ \min_{j \lt i,\ pos[j] \lt pos[i]}(dp[j]+\sum_{k=j+1}^{i-1}A_k)) \]
+
+The DP above costs \(O(N^2)\) naively, but it can be optimized to \(O(N \log N)\) by segment trees and cumulative sums.
+
+Once the DP is processed, we can obtain the answer as \(\min_{1 \leq i \leq N}(dp[i]+\sum_{j=i+1}^{N} \min(A_j,C_j))\). Therefore we could solve the problem.
+
+Note that \(S\) can never be empty in the optimal solution. If \(S\) is empty, there exists an integer \(i\ (0 \leq i \leq N)\) such that
+
+- every person \(j\) such that \(j \leq i\) is assigned either operation of being moved to an arbitrary position with cost \(A_i\) or being moved to the left end with cost \(B_j\), and
+- every person \(j\) such that \(i \lt j\) is assigned either operation of being moved to an arbitrary position with cost \(A_i\) or being moved to the right end with cost \(C_j\).
+
+Here, one can add to \(S\) either of the person \(i\) or \(i+1\) that exists (or one of them if both exist) so that the total cost is strictly less than that of empty \(S\).

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

problems/DP-04/Atcoder/abc201_f/meta.json

@@ -0,0 +1,16 @@
+{
+  "task_id": "abc201_f",
+  "contest": "abc201",
+  "type": "ABC",
+  "letter": "F",
+  "title": "Insertion Sort",
+  "url": "https://atcoder.jp/contests/abc201/tasks/abc201_f",
+  "difficulty": 2484,
+  "score": 600,
+  "time_limit_sec": 2.0,
+  "memory_limit_mb": 1024,
+  "n_tests": 27,
+  "editorial_url": "https://atcoder.jp/contests/abc201/editorial/1838",
+  "code_source": "editorial",
+  "pid": "A1584"
+}

problems/DP-04/Atcoder/abc201_f/solution.cpp

@@ -0,0 +1,42 @@
+// abc201_f: F - Insertion Sort
+// Code from the official editorial, https://atcoder.jp/contests/abc201/editorial/1838 (by en_translator)
+// Judged AC on all 27 tests, max 0.17 s of the 2 s limit.
+
+#include<bits/stdc++.h>
+#include<atcoder/all>
+using namespace std;
+using namespace atcoder;
+using ll = long long;
+const ll inf = (1ll<<60);
+
+ll op(ll a,ll b){
+    return min(a,b);
+}
+
+ll e(){
+    return inf;
+}
+
+int main(){
+    int N; cin >> N;
+    vector<int> P(N),A(N),B(N),C(N),pos(N+1);
+    for(int i=0; i<N; i++){
+        cin >> P[i];
+        pos[P[i]] = i+1;
+    }
+    for(int i=0; i<N; i++) cin >> A[i] >> B[i] >> C[i];
+    vector<ll> dp(N+1,inf),Asum(N+1),Bsum(N+1),Csum(N+1);
+    segtree<ll,op,e> seg(N+1);
+    ll ans = inf;
+    for(int i=0; i<N; i++){
+        Asum[i+1] = Asum[i]+A[i];
+        Bsum[i+1] = Bsum[i]+min(B[i],A[i]);
+        Csum[i+1] = Csum[i]+min(C[i],A[i]);
+    }
+    for(int i=1; i<=N; i++){
+        dp[i] = min(Bsum[i-1],seg.prod(0,pos[i])+Asum[i-1]);
+        ans = min(ans, dp[i]+Csum[N]-Csum[i]);
+        seg.set(pos[i],dp[i]-Asum[i]);
+    }
+    cout << ans << endl;
+}

problems/DP-04/Atcoder/abc201_f/statement.md

@@ -0,0 +1,119 @@
+# F - Insertion Sort
+
+**Score:** 600 points
+
+## Problem Statement
+
+There are \( N \) people, who are given ID numbers \( 1 \) through \( N \), standing in a row from left to right. Initially, the ID number of the \( i \)-th person from the left is \( P_i \).
+
+Your objective is to rearrange the people in ascending order of the ID number from left to right, by repeatedly doing the three kinds of operations below. You can do these operations any number of times (possibly zero) in any order.
+
+- Choose an integer \( i\ (1 \leq i \leq N) \), pay the cost \( A_i \), and move Person \( i \) (the person with the ID number \( i \)) to any position of your choice.
+- Choose an integer \( i\ (1 \leq i \leq N) \), pay the cost \( B_i \), and move Person \( i \) to the left end of the row.
+- Choose an integer \( i\ (1 \leq i \leq N) \), pay the cost \( C_i \), and move Person \( i \) to the right end of the row.
+
+Minimize the total cost you pay before achieving the objective.
+
+## Constraints
+
+- \( 1 \leq N \leq 2 \times 10^5 \)
+- \( 1 \leq P_i \leq N \)
+- \( 1 \leq A_i, B_i, C_i \leq 10^9 \)
+- \( P_i \neq P_j\ (i \neq j) \)
+- All values in input are integers.
+
+## Input
+
+Input is given from Standard Input in the following format:
+
+```
+N
+P_1 P_2 ... P_N
+A_1 B_1 C_1
+A_2 B_2 C_2
+...
+A_N B_N C_N
+```
+
+## Output
+
+Print the minimum total cost you need to pay before achieving the objective.
+
+## Sample Input 1
+```
+3
+3 1 2
+9 3 5
+8 6 4
+9 4 6
+```
+
+## Sample Output 1
+```
+6
+```
+You can rearrange the people in ascending order of the ID number by paying the cost \( C_3=6 \) to move Person \( 3 \) to the right end. There is no way to rearrange the people that costs less, so the answer is \( 6 \).
+
+## Sample Input 2
+```
+6
+2 6 5 3 4 1
+10 8 16
+30 2 10
+10 17 8
+11 27 22
+8 6 5
+15 29 2
+```
+
+## Sample Output 2
+```
+15
+```
+The following sequence of operations minimizes the total cost:
+- pay the cost \( B_1=8 \) to move Person \( 1 \) to the left end;
+- pay the cost \( C_5=5 \) to move Person \( 5 \) to the right end;
+- pay the cost \( C_6=2 \) to move Person \( 6 \) to the right end.
+
+## Sample Input 3
+```
+9
+3 8 4 7 6 9 1 5 2
+7976 3696 9706
+768 8807 8521
+1133 8683 7120
+1189 3331 2259
+900 7451 1159
+6126 2639 7107
+5540 8253 2891
+8417 4220 9091
+8732 1417 1540
+```
+
+## Sample Output 3
+```
+15865
+```
+
+## Sample Input 4
+```
+12
+11 9 1 12 2 7 3 5 10 4 6 8
+3960 3158 9029
+6521 6597 7581
+5688 2299 2123
+4946 4298 9122
+394 4350 9142
+3098 7151 2039
+8525 3758 6155
+6970 3658 9353
+9780 1778 3608
+6065 5562 923
+9701 5524 6482
+9395 6016 705
+```
+
+## Sample Output 4
+```
+20637
+```

problems/DP-04/Atcoder/abc203_e/editorial.md

@@ -0,0 +1,31 @@
+# E - White Pawn (editorial)
+
+Source: https://atcoder.jp/contests/abc203/editorial/2010 by en_translator
+
+Consider maintaining a set of squares (the indices of columns), updating incrementally for each row.
+ In other words, let \(S_i=\{ j\in\mathbb{Z} \mid \)the white pawn can reach \((i,j)\)\(\}\ (0\leq i \leq 2N)\), and we want to derive \(S_{i+1}\) from \(S_i\) for each \(i=0,1,\ldots 2N-1\).
+ Of course, if we do this naively, it will exceed the time limit.
+
+Actually however, we can only focus on the difference between \(S_i\) and \(S_{i+1}\) to drastically improve the computation time. The key fact is:
+
+- Suppose that \((i+1, j)\) has no black pawn. If the white pawn is reachable to \((i, j)\), so is \((i+1 ,j)\); if it cannot reach \((i,j)\), then it cannot to \((i+1 ,j)\) either.
+
+First, we can now see that \(S_i=S_{i-1}\) if the \(i\)-th row does not contain black pawns. Also, even for the row with black pawns, the between transitions from \(S_{i-1}\) to \(S_i\) are either:
+
+- If ( \(j-1 \in S_{i-1}\) or \(j+1 \in S_{i-1}\) ) and \(j \notin S_{i-1}\), then \(j \notin S_{i-1} \to j \in S_i\).
+- If ( \(j-1 \notin S_{i-1}\) and \(j+1 \notin S_{i-1}\) ) and \(j \in S_{i-1}\), then \(j \in S_{i-1} \to j \notin S_i\).
+
+Moreover, since any \(j\) such that \(j<0\) or \(2N<j\) can never be given as an column index of a black pawn, and since \(j\notin S_0\), \(j\notin S_i\) for every \(i\), so we do not have to take care of the left and right boundary.
+
+Therefore, only focusing on the squares with black pawns, it can be solved as follows. First, sort \((X_i, Y_i)\) in the increasing order. Next, starting from \(S=\{N\}\), for each chunk with the equal \(X_i\) in the sorted sequence, repeat the following. We assume \(X_l=X_{l+1}=\cdots =X_r\).
+
+- Prepare a set \(A\) that will eventually be added to \(S\) and a set \(B\) that will be removed from \(S\), both initialized with empty sets. For each \(i=l,l+1, \ldots, r\), perform the following operations:
+
+  - If ( \(Y_i-1 \in S\) or \(Y_i+1 \in S\) ) and \(Y_i \notin S\), then add \(Y_i\) to \(A\).
+  - If ( \(Y_i-1 \notin S\) and \(Y_i+1 \notin S\) ) and \(Y_i \in S\), then add \(_i\) to \(B\).
+  - Otherwise, do nothing.
+- Update \(S\) by adding the elements of \(A\) to \(S\) and removing the elements of \(B\) from \(S\).
+
+The final set \(S\) is a set of indices \(j\) such the white pawn is reachable to \((2N, j)\), and the desired answer is the size of the set \(\lvert S\rvert\).
+
+The time complexity is \(O(M\log M)\) for the initial sort, \(O(\log M)\) for each lookup, addition, and removal if an ordered “set” is used, so \(O(M\log M)\) in total. Therefore, the problem can be solved in \(O(M\log M)\) time, which is fast enough. Also, by the facts so far, if the white pawn is reachable to \((2N,j)\) then \(j = N\) or the row \(j\) has at least one black pawn, so the answer is at most \(M+1\), which fits in a \(32\)-bit integer.

problems/DP-04/Atcoder/abc203_e/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/DP-04/Atcoder/abc203_e/meta.json

@@ -0,0 +1,16 @@
+{
+  "task_id": "abc203_e",
+  "contest": "abc203",
+  "type": "ABC",
+  "letter": "E",
+  "title": "White Pawn",
+  "url": "https://atcoder.jp/contests/abc203/tasks/abc203_e",
+  "difficulty": 1750,
+  "score": 500,
+  "time_limit_sec": 2.0,
+  "memory_limit_mb": 1024,
+  "n_tests": 40,
+  "editorial_url": "https://atcoder.jp/contests/abc203/editorial/2010",
+  "code_source": "editorial",
+  "pid": "A1595"
+}

problems/DP-04/Atcoder/abc203_e/solution.cpp

@@ -0,0 +1,42 @@
+// abc203_e: E - White Pawn
+// Code from the official editorial, https://atcoder.jp/contests/abc203/editorial/2010 (by en_translator)
+// Judged AC on all 40 tests, max 0.21 s of the 2 s limit.
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int main(void) {
+	int n, m;
+	vector<pair<int, int> > p;
+	vector<int>a, b;
+	set<int>s;
+	int x, y;
+	int l, r;
+	cin >> n >> m;
+	for (int i = 0; i < m; i++) {
+		cin >> x >> y;
+		p.push_back({ x,y });
+	}
+	sort(p.begin(), p.end());
+	s.insert(n);
+	l = 0;
+	while (l < m) {
+		a.clear();
+		b.clear();
+		r = l;
+		while (r < m) {
+			if (p[r].first == p[l].first)r++;
+			else break;
+		}
+		for (int i = l; i < r; i++) {
+			y = p[i].second;
+			if (((s.find(y - 1) != s.end()) || (s.find(y + 1) != s.end())) && (s.find(y) == s.end()))a.push_back(y);
+			if (((s.find(y - 1) == s.end()) && (s.find(y + 1) == s.end())) && (s.find(y) != s.end()))b.push_back(y);
+		}
+		for (int i = 0; i < a.size(); i++)s.insert(a[i]);
+		for (int i = 0; i < b.size(); i++)s.erase(b[i]);
+		l = r;
+	}
+	cout << s.size() << endl;
+}

problems/DP-04/Atcoder/abc203_e/statement.md

@@ -0,0 +1,72 @@
+# E - White Pawn
+
+**Score :** 500 points
+
+## Problem Statement
+
+Let \( N \) be a positive integer.  
+We have a \( (2N+1)\times (2N+1) \) grid where rows are numbered \( 0 \) through \( 2N \) and columns are also numbered \( 0 \) through \( 2N \). Let \( (i,j) \) denote the square at Row \( i \) and Column \( j \).  
+
+We have one white pawn, which is initially at \( (0, N) \).  
+Also, we have \( M \) black pawns, the \( i \)-th of which is at \( (X_i, Y_i) \).  
+
+When the white pawn is at \( (i, j) \), you can do one of the following operations to move it:
+- If \( 0 \leq i \leq 2N-1 \), \( 0 \leq j \leq 2N \) hold and \( (i+1,j) \) **does not** contain a black pawn, move the white pawn to \( (i+1, j) \).
+- If \( 0 \leq i \leq 2N-1 \), \( 0 \leq j \leq 2N-1 \) hold and \( (i+1,j+1) \) **does** contain a black pawn, move the white pawn to \( (i+1,j+1) \).
+- If \( 0 \leq i \leq 2N-1 \), \( 1 \leq j \leq 2N \) hold and \( (i+1,j-1) \) **does** contain a black pawn, move the white pawn to \( (i+1,j-1) \).
+
+You cannot move the black pawns.  
+Find the number of integers \( Y \) such that it is possible to have the white pawn at \( (2N, Y) \) by repeating these operations.
+
+## Constraints
+- \( 1 \leq N \leq 10^9 \)
+- \( 0 \leq M \leq 2\times 10^5 \)
+- \( 1 \leq X_i \leq 2N \)
+- \( 0 \leq Y_i \leq 2N \)
+- \( (X_i, Y_i) \neq (X_j, Y_j) \) \( (i \neq j) \)
+- All values in input are integers.
+
+## Input
+Input is given from Standard Input in the following format:
+```
+N M
+X_1 Y_1
+:
+X_M Y_M
+```
+
+## Output
+Print the answer.
+
+## Sample Input 1
+```
+2 4
+1 1
+1 2
+2 0
+4 2
+```
+
+## Sample Output 1
+```
+3
+```
+We can move the white pawn to \( (4,0) \), \( (4,1) \), and \( (4,2) \), as follows:
+- \( (0,2)\to (1,1)\to (2,1)\to (3,1)\to (4,2) \)
+- \( (0,2)\to (1,1)\to (2,1)\to (3,1)\to (4,1) \)
+- \( (0,2)\to (1,1)\to (2,0)\to (3,0)\to (4,0) \)
+
+On the other hand, we cannot move it to \( (4,3) \) or \( (4,4) \).  
+Thus, we should print \( 3 \).
+
+## Sample Input 2
+```
+1 1
+1 1
+```
+
+## Sample Output 2
+```
+0
+```
+We cannot move the white pawn from \( (0,1) \).

problems/DP-04/Atcoder/abc204_f/data/1.in

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

problems/DP-04/Atcoder/abc204_f/data/1.out

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

problems/DP-04/Atcoder/abc204_f/data/10.in

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

problems/DP-04/Atcoder/abc204_f/data/10.out

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

problems/DP-04/Atcoder/abc204_f/data/11.in

@@ -0,0 +1 @@
+4 8

problems/DP-04/Atcoder/abc204_f/data/11.out

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

problems/DP-04/Atcoder/abc204_f/data/12.in

@@ -0,0 +1 @@
+4 1000000000000

problems/DP-04/Atcoder/abc204_f/data/12.out

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

problems/DP-04/Atcoder/abc204_f/data/13.in

@@ -0,0 +1 @@
+5 4

problems/DP-04/Atcoder/abc204_f/data/13.out

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