Codeforces 题解集合

大概只会放 *2000 以上的题目上去了

[Change Log]

created on 2022.5.6
latest updated on 2022.12.6

Div1
Div1 + Div2 & Global Round
- Global Round 20
  - D. Cyclic Rotation ( $\color{#AAF}{1700}$ )
- Global Round 21
  - D. Permutation Graph ( $\color{#F9F}{1900}$ )
Div2
Education Round
Div3/4
野场

Div1

先留着（

Div1 + Div2 & Global Round

Global Round 20

D. Cyclic Rotation ( $\color{#AAF}{1700}$ )

构造，双指针, multiset，逆向，等价变换

题意

给定长度为 $n$ 的数组 $a$，和 $a$ 的一个排列数组 $b$，对 $a$ 进行操作：

如果 $a_l =a_r$，则 $[a_l,...,a_r] = [a_{l+1},...,a_r,a_l],\; 1\leq l<r\leq n$。

询问能否对 $a$ 进行任意次操作得到 $b$

数据范围
$1\leq n \leq 2 * 10^5$
$1\leq a_i,b_i \leq n$

思路

对操作进行等价变换，每次对 $a_l,a_r$ 的操作相当于把 $a_l$ 删除，在 $a_r$ 前拷贝一份 $a_r$ 。
尝试逆向,我们看能否从 $b$ 得到 $a$。
双指针构造方案：
- $i,j$ 指向 $a,b$ 最后一个元素，维护一个 multiset
- while (b[j] == b[j - 1]) j--; ，向 multiset 中插入 $b_j$
- 如果 $a_i = b_j$ , i--,j--
- 否则，在 multiset 中查找 $a_i$ ，找到则 i-- 否则无解。
因为每次操作，$a_r$ 的位置其实相对是不变的，然后根据第一点，我们从右往前查 multiset中没有的元素一定不合法。

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef unsigned long long ull;
typedef double db;
#define arr(x) (x).begin(),(x).end()
#define x first
#define y second
#define pb push_back
#define endl "\n"
using namespace std;
/*----------------------------------------------------------------------------------------------------*/

template<class T>
struct BIT {
    int n;
    vector<T> B;
    BIT(){};
    BIT(int _n) : n(_n), B(_n + 1, 0) {}
    void init(int _n) {
            n = _n;
            B.resize(_n + 1);
    }
    inline int lowbit(int x) { return x & (-x); }
    void add(int x, T v) {
            for (int i = x; i <= n; i += lowbit(i)) B[i] += v;
    }
    T ask(int x) {
            T res = 0;
            for (int i = x; i; i -= lowbit(i)) res += B[i];
            return res;
    }
};

int main() {
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        vector<int> a(n), b(n);
        for (auto &x : a)
            cin >> x;
        for (auto &x : b)
            cin >> x;
        int j = n - 1, i = n - 1;
        multiset<int> s;
        bool fl = true;
        while (i && j && fl) {
            while (i && j && b[j] == b[j - 1]) {
                s.insert(b[j]);
                j--;
            }
            if (a[i] == b[j]) 
                i--, j--;
            else {
                if (s.find(a[i]) != s.end()) {
                    s.erase(s.find(a[i]));
                    i--;
                }
                else fl = false;
            }
        }
        fl ? cout << "YES\n" : cout << "NO\n";
    }
    return 0;
}

Global Round 21

D. Permutation Graph ( $\color{#F9F}{1900}$ )

构造，分治，或数据结构贪心

题意

给定长度为 $n$ 的排列，有 $n$ 个点，两点 l, r 之间当且仅当下标区间在 $[l,r]$ 中 $a[l], a[r]$ 为区间的两个最值，可以连边，询问从 $1-n$ 的最短路。

数据范围
$1\leq n \leq 2.5*10^5$

思路

抓住题目性质，先找到区间最大值的位置 $pos$ ，假设 $pos\neq1,n$
横跨 $pos$ 的区间两点是不可能连边的，所以分治求解 $dist(1,pos),\; dist(pos, n)$
对于 $dist(1,pos)$ ，我们找出 [1,pos] 区间的最小值位置 $mi$，递归求解 $dist(1,mi),\; dist(mi, pos)$, 且 $dist(mi,pos)$ 返回 1。
对于 $dist(pos,n)$ 求解方式相同，依次递归出口为两端点相同。区间满足条件 l != 1 && r != n 就表明是区间两最值端点应当 return $1$
然后需要一点细节，就通过本题，时间复杂度为 $O(n)$ 。

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef unsigned long long ull;
typedef double db;
#define arr(x) (x).begin(),(x).end()
#define x first
#define y second
#define pb push_back
#define endl "\n"
using namespace std;
/*----------------------------------------------------------------------------------------------------*/
int n;
const int N = 3e5;
int a[N], premx[N], premin[N], sufmx[N], sufmin[N];

int dist(int l, int r) {
    // cout << l << " " << r << endl;
    if (l == r) return 0;
    if (l == 1) {
        if (a[r] == premin[r]) {
            if (a[l] == premx[r])
                return 1;
            for (int i = r - 1; i; i--)
                if (a[i] == premx[i])
                    return dist(1, i) + dist(i, r);
        }
        else if (a[r] == premx[r]) {
            if (a[l] == premin[r])
                return 1;
            for (int i = r - 1; i; i--)
                if (a[i] == premin[i])
                    return dist(1, i) + dist(i, r);
            exit(0);
            
        }
    }
    else if (r == n) {
        if (a[l] == sufmin[l]) {
            if (a[r] == sufmx[l])
                return 1;
            for (int i = l + 1; i <= n; i++) 
                if (a[i] == sufmx[i])
                    return dist(l, i) + dist(i, n);
        }
        else if (a[l] == sufmx[l]) {
            if (a[r] == sufmin[l])
                return 1;
            for (int i = l + 1; i <= n; i++) {
                if (a[i] == sufmin[i])
                    return dist(l, i) + dist(i, n);
            }
        }
    }
    return 1;
}

int main() {
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int T;
    cin >> T;
    while (T--) {
        cin >> n;

        for (int i = 1; i <= n; i++){
            cin >> a[i];
            premx[i] = premin[i] = sufmx[i] = sufmin[i] = 0;
        }
        for (int i = 1; i <= n; i++) {
            if (i == 1)
                premx[i] = premin[i] = a[i];
            else {
                premx[i] = max(premx[i - 1], a[i]);
                premin[i] = min(premin[i - 1], a[i]);
            }
        }
        for (int i = n; i; i--) {
            if (i == n)
                sufmx[i] = sufmin[i] = a[i];
            else {
                sufmx[i] = max(sufmx[i + 1], a[i]);
                sufmin[i] = min(sufmin[i + 1], a[i]);
            }
        }
        if (n != 1 && ((premin[n] == a[1] && premx[n] == a[n]) || (premin[n] == a[n] && premx[n] == a[1]))) {
            cout << 1 << endl;
            continue;
        }
        int pos = max_element(a + 1, a + 1 + n) - a;
        if (pos == n || pos == 1) {
            int mi = min_element(a + 1, a + 1 + n) - a;
            if (pos == n) cout << dist(1, mi) + (n != 1) << endl;
            else cout << dist(mi, n) + (n != 1) << endl;
        }
        else 
            cout << dist(1, pos) + dist(pos, n) << endl;
    }
    return 0;
}

Div2

Round #264 div2

D. Bear and Floodlight ($\color{#FA8}{2200}$)

状压DP，简单计算几何

题意

在二维坐标上，一个人从 $(l,0)$ 走到 $(r,0)$ ，有 $n$ 盏路灯，每盏灯的照射角度最大为 $a_i$，坐标为 $(x_i,y_i)$。询问这个人最多能走多远，到 $r$ 停止。

数据范围
$1\leq n\leq 20$
$-10^5 \leq l\leq r \leq 10^5$
$-1000\leq x_i\leq 1000, 1\leq y_i \leq 1000, 1\leq a_i\leq 90$

思路

观察数据范围， $n\leq 20$ ，两种想法，选和不选和二进制枚举，自然是二进制枚举。
涉及二进制枚举，一个很自然的想法是状压DP，设计一下状态。
发现对于每盏灯的贡献和当前所在点有关。不妨设状态 $f[i]$ 表示状态为 $i$ 时能到达的最远距离。
状态转移：f[i | (1<<j)] = max(f[i|(1<<j)], calc(f[i], j)) ，calc 表示当前在 f[i] 点，第 $j$ 盏灯能到达的最远距离
计算 calc() 函数
- 可以用 atan2 求出 $P(f[i],0)$ 对应的角，用内角和算出 $B(x_b,0)$ 对应的角，然后用其补角 tan 求出 $x - x_b$，进而求出 $x_b$
- 也可以用旋转矩阵，先求出向量 $(dx,dy)=(f[i]-x,-y)$ 做逆时针旋转矩阵新的向量 $(dx,dy)=(dx * cos(a) - dy*sin(a),dx*sin(a)+dy*cos(a))$ ，那么 $x_b = x - y * dx/dy$
- 两种情况都需要特判，最远点是无穷大或者其他边界问题。
目标答案为 $f[(1<<n)-1]$ ，时间复杂度为 $O(n*2^n)$

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef unsigned long long ull;
typedef double db;
#define arr(x) (x).begin(),(x).end()
#define x first
#define y second
#define pb push_back
#define endl "\n"
using namespace std;
/*----------------------------------------------------------------------------------------------------*/
const double PI = acos(-1);
const int N = 1 << 20;
int n;
double l, r;
double f[N];

struct P{
    double x, y, a;
};

// double cal(double l, P& p) {
//     auto [x, y, a] = p;
//     double dx = l - x, dy = -y;
//     double nx = dx * cos(a) - dy * sin(a), ny = dx * sin(a) + dy * cos(a);
//     if (fabs(ny) < 1e-12) return r;
//     if (ny > 0) return r;
//     return min(x - y * nx / ny, r);
// }

double cal(double l, P& p) {
    auto [x, y, a] = p;
    double angleA = atan2(y, x - l);
    if (angleA + a >= PI)
        return r;
    double angleB = PI - angleA - a;
    if (angleB == PI / 2) 
        return x;
    return x + y / tan(angleB);
}

int main() {
    cin >> n >> l >> r;
    vector<P> p(n);
    r -= l;
    for (int i = 0; i < n; i++) {
        cin >> p[i].x >> p[i].y >> p[i].a;
        p[i].x -= l;
        p[i].a *= PI / 180;
    }
    for (int i = 0; i < 1 << n; i++) {
        for (int j = 0; j < n; j++) {
            if ((i >> j & 1) == 0) {
                int nxt = i + (1 << j);
                f[nxt] = max(f[nxt], cal(f[i], p[j]));
            }
        }
    }
    double ans = f[(1<<n) - 1];
    cout << fixed << setprecision(9) << min(ans, r) << endl;
    return 0;
}

E. Bear in the Field ($\color{#FB5}{2300}$)

矩阵快速幂

题意

在大小为 $n\times n$ 的棋盘上，一个点起始坐标为 $(sx,sy)$ 起始速度是 $(dx,dy)$ ，询问经过 $t$ 秒后的位置，对于每一秒：

点处于 $(i,j)$，给速度的贡献为 $k$, 速度将变为 $(dx+k, dy+k)$
移动到 $(x+dx-1, y + dy-1)$, 这里的 $dx,dy$ 已经更新
每个点给速度的贡献 $+1$。

数据范围
$1\leq n \leq 10^9$
$1\leq sx,sy \leq n$
$-100\leq dx,dy \leq 100$
$0\leq t \leq 10^{18}$

思路

观察数据范围，$t\leq 10^{18}$ 很大很大，相当于询问你经过 $t$ 步之后的位置，显然的矩阵快速幂。
状态矩阵参数：$(dx,dy,x,y,0,1)$ 其中 $0$ 其实代表当前经过的时间。
转移矩阵，先看如何转移：
- 因为运算过程中涉及对 $n$ 取模，先将坐标下标从 $0$ 开始比较好算。
- $dx = dx + (x + y + 2) + t$
- $dy = dy + (x + y + 2) + t$
- $x = x + dx + (x + y + 2) + t$
- $y = y + dy + (x + y + 2) + t$
- $t = t + 1$
- $1 = 1$
- 故状态矩阵为
\[ \begin{bmatrix} 1 & 0 & 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 1 & 0 & 0 \\ 1 & 1 & 2 & 1 & 0 & 0 \\ 1 & 1 & 1 & 2 & 0 & 0 \\ 1 & 1 & 1 & 1 & 1 & 0 \\ 2 & 2 & 2 & 2 & 1 & 1 \\ \end{bmatrix} \]
时间复杂度为 $O(6^3 * logt)$

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef unsigned long long ull;
typedef double db;
#define arr(x) (x).begin(),(x).end()
#define x first
#define y second
#define pb push_back
#define endl "\n"
using namespace std;
/*----------------------------------------------------------------------------------------------------*/
ll n, val;
#define _DEBUG

template <typename T, const int N> struct Mat {
       int len;

       Mat() { memset(data, 0, sizeof(data)); len = N; }

       T *operator[](int i) { return data[i]; }

       const T *operator[](int i) const { return data[i]; }

       T add(T a, T b){
               return (a + b + val) % n;
       }

       Mat &operator += (const Mat &o) {
               for (int i = 0; i < len; ++i) 
                       for (int j = 0; j < len; ++j) 
                               data[i][j] = add(data[i][j], o[i][j]);
               return *this;
       }

       Mat operator + (const Mat &o) const {
               return Mat(*this) += o;
       }

       Mat &operator -= (const Mat &o) {
               for (int i = 0; i < len; ++i) 
                       for (int j = 0; j < len; ++j) 
                               data[i][j] = add(data[i][j], -o[i][j]);
               return *this;
       }

       Mat operator-(const Mat &o) const {
               return Mat(*this) -= o;
       }

       Mat operator*(const Mat &o) const {
               static T buffer[N];
               Mat result;
               for (int j = 0; j < len; ++j) {
                       for (int i = 0; i < len; ++i) 
                               buffer[i] = o[i][j];
                       for (int i = 0; i < len; ++i) 
                               for (int k = 0; k < len; ++k) 
                                       result[i][j] = (result[i][j] + (data[i][k] * buffer[k]) + val)% n;
               }
               return result;
       }

       Mat power(ull k) const {
               Mat res;
               for (int i = 0; i < len; ++i) 
                       res[i][i] = T{1};
               Mat a = *this;
               while (k) {
                       if (k & 1ll) 
                               res = res * a;
                       a = a * a;
                       k >>= 1ll;
               }
               return res;
       }
       private:
               T data[N][N];
};

int main() {
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    ll sx, sy, dx, dy, t;
    cin >> n >> sx >> sy >> dx >> dy >> t;
    sx--, sy--;
    val = 10000 * n;
    Mat<ll, 6> a;
    Mat<ll, 6> b;
    b[0][0] = dx, b[0][1] = dy, b[0][2] = sx, b[0][3] = sy, b[0][4] = 0, b[0][5] = 1;
    a[0][0] = a[0][2] = a[1][1] = a[1][3] = a[2][0] = a[2][1] = a[2][3] = 1;
    a[3][0] = a[3][1] = a[3][2] = a[4][0] = a[4][1] = a[4][2] = a[4][3] = a[4][4] = a[5][4] = a[5][5] = 1;
    a[2][2] = a[3][3] = a[5][0] = a[5][1] = a[5][2] = a[5][3] = 2; 
    #ifdef _DEBUG
    for (int i = 0; i < 6; i++) {
        for (int j = 0; j < 6; j++) {
            cout << a[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;
    for (int i = 0; i < 6; i++)
        cout << b[0][i] << " ";
    cout << endl;
    #endif
    a = a.power(t);
    Mat<ll, 6> res;
    b = b * a;
    cout << b[0][2] + 1 << " " << b[0][3] + 1 << endl;
    return 0;
}

Round #564 div2

D.Nauuo and Circle ( $\color{#F9F}{1900}$ ) (结论、计数)

题意

给了一颗 $n$ 个节点的树，询问存在多少种合法排列，使得 $n$ 个点在圆环上排列对应位置上，相连的边不会有相交。

答案模 $998244353$

数据范围
$2\leq n \leq 2 * 10^5$

思路

核心点：一个结论：一个节点的子树所有点在圆环上连续的一段。
所以一个节点的子节点可以有阶乘级别的排列。
更正式的表达，$f[u] = ((u != root) + son[u]!) * \Pi_{v\in son[u]}{f[v]}$
由于整棵树根可以随意设置，但最后效果其实和 $1$ 放在 $n$ 个位置上的效果一样，所以最后答案等于 $n * f[1]$ , 而实际上把每个点的度数阶乘相乘即可。

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef unsigned long long ull;
typedef double db;
#define arr(x) (x).begin(),(x).end()
#define x first
#define y second
#define pb push_back
#define endl "\n"
using namespace std;
/*----------------------------------------------------------------------------------------------------*/
const int N = 2e5 + 10, mod = 998244353;
ll fact[N], d[N];

// f[u] = ((u != root) + son[u]!) * \PI{f[v]}

int main() {
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    for (int i = 1; i < n; i++) {
        int a, b;
        cin >> a >> b;
        d[a] ++, d[b]++;
    }
    fact[0] = 1;
    for (int i = 1; i <= n; i++) fact[i] = fact[i - 1] * i % mod;
    ll ans = n;
    for (int i = 1; i <= n; i++) ans = ans * fact[d[i]] % mod;
    cout << ans << endl;
    return 0;
}

Round #747 div2

C. Make Them Equal ( $\color{#9F7}{1200}$ )

题意

输入长度为 $n$ 的字符串 $s$ 和一个字符 $c$ ，可以进行一个操作，对于 $1≤x≤n$ ,可以将不能整除 $x$ 的 $i(1≤i≤n)$ ,所在的下标字符替换成 $c$ ，问最少经过多少次操作可以使 $s$ 每个字符都是 $c$ ？

思路

由整除出发，
- 对于 $x=n$ 而言，$1≤i≤n-1$ 都可以被替换。
- 对于 $x=n-1$ 而言，$i=n$ 可以被替换。
因此最多需要2次操作就可以将 $s$ 替换成想要的字符串。
对于做 $0$ 次操作，遍历数组就行。
对于做 $1$ 次操作，当数组中$\exists i<n$，$i$ 及 $i$ 的倍数下标位置的字符都是 $c$ 的话，只需要一次操作就可以把 $s$ 都替换成 $c$ ，输出 $i$ 的下标。
对于做 $2$ 次操作，就是 $\nexists i<n$ ，$i$ 及 $i$ 的倍数下标位置的字符都是 $c$ ，输出 $n-1$ 和 $n$。

赛中

上述的第一点想到了，但是忽略了做1次操作的做法，也是这道题的核心，由第1点衍生出，$i$可以替换不是它倍数的下标位置（~~其实就是题意~~)。~~太蠢了~~

Solution

#include<iostream>
#include<cstring>
using namespace std;
int main(){
    int T;
    scanf("%d", &T);
    while(T--){
        int n;
        char c;
        string s;
        cin >> n >> c;
        cin >> s;
        bool flag = true;
        for(int i = 0; i < n; i++){
            if(s[i] != c){
                flag = false;
                break;
            }
        }
        if(flag){
            printf("0\n");
            continue;
        }
        bool f = false;
        for(int i = 1; i <= n; i++){
            flag = true;
            for(int j = i; j <= n; j += i){
                if(s[j - 1] != c){
                    flag = false;
                    break;
                }
            }
            if(flag){
                f = true;
                printf("1\n%d\n", i);
                break;
            }
        }
        if(!f){     // 1-n-1不存在能代替所有字符的位置
            printf("2\n%d %d\n", n - 1, n);
        }
    }
    return 0;
}

Round #782 div2

D. Reverse Sort Sum ( $\color{}{1900}$ )

构造、逆序操作

题意

求一个长度为 $n$ 的 01 数组 $A$，对 $A$ 进行 $n$ 次操作，每次对 $[1,n]$ 的区间进行排序结果累加到 $C$ 数组中，已知 $C$ 数组求 $A$ 数组。

数据范围
$1\leq n \leq 2 * 10^5$
$0\leq c_i \leq n$

思路

观察1：将 $C$ 数组求和 $/n$ 可以得到 $1$ 的个数 $num$。由贡献思考
观察2：如果 $C_n=n/1$ ，那么 $A_n = 1/0$ 。
由观察1得到 1 的个数，抓住题目性质，在第 $n$ 次操作时，是由后缀为 $num$ 个 $1$ 的数组累加。$A_n$ 已经求出，看前 $n-1$ 位，如果我们把第$n$ 次的后缀累加给撤销，得到的 $C[1,n-1]$ 其实是第 $n-1$ 次操作累加之后的 $C$ 的前 $n-1$ 位，这时候可以不用管 $A_n,C_n$ 。然后同理如果 $C_{n-1}=n-1/1,\; A_{n-1} = 1/0$ 。就这样往前递推。
但需要注意，如果该位为 $1$ ，$num$ 需要减 1，很好理解，在 $i$ 之前 $A_i=1$ 没有在排序范围内自然也不属于后缀。
涉及区间更新操作就懒得 $O(n)$ 搞来搞去了，直接上差分树状数组，复杂度 $O(n*logn)$。

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef unsigned long long ull;
typedef double db;
#define arr(x) (x).begin(),(x).end()
#define x first
#define y second
#define pb push_back
#define endl "\n"
using namespace std;
/*----------------------------------------------------------------------------------------------------*/

template<class T>
struct BIT {
    int n;
    vector<T> B;
    BIT(){};
    BIT(int _n) : n(_n), B(_n + 1, 0) {}
    void init(int _n) {
            n = _n;
            B.resize(_n + 1);
    }
    inline int lowbit(int x) { return x & (-x); }
    void add(int x, T v) {
            for (int i = x; i <= n; i += lowbit(i)) B[i] += v;
    }
    T ask(int x) {
            T res = 0;
            for (int i = x; i; i -= lowbit(i)) res += B[i];
            return res;
    }
};

int main() {
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        vector<int> c(n + 1), ans(n + 1, 0);
        BIT<int> bt(n);
        ll num = 0;
        for (int i = 1; i <= n; i++) {
            cin >> c[i];
            num += c[i];
            bt.add(i, c[i]), bt.add(i + 1, -c[i]);
        }
        num /= n;
        for (int i = n; i; i--) {
            if (bt.ask(i) >= i) {
                ans[i] = 1;
                bt.add(i - num + 1, -1);
                bt.add(i + 1, 1);
                num--;
            }
        }
        for (int i = 1; i <= n; i++)
            cout << ans[i] << " ";
        cout << endl;
    }
    return 0;
}

Round #788 div2

E. Hemose on the Tree ( $\color{#FA8}{2200}$ )

构造

题意

给了 $n$ 个点的树， $n$ 是 $2$ 的幂次，边权和点权是 $[1, 2 * n - 1]$ 的排列。询问从任意点为根，从根出发途中经过的的点和路径权值 $异或$ 最大值的最小值是多少？

数据范围
$1\leq p\leq 17$
$2^p = n$

思路

首先如果单独选一个大于 $2^n$ 的点为根，最大值 $\geq 2^p$ ，所以考虑根权值为 $2^p$ ，并且途径最大值为 $2^p$ ，其实就是一个构造
接下来需要 $n-1$ 对数分别为 $x, x + 2^p$
分类讨论构造一下
- 父节点 $>= 2^p$，子节点值为 $x$ ，边为 $x + 2^p$
- 父节点 $< 2^p$，子节点值为 $x + 2^p$，边为 $x$
这样构造到根的子节点，异或和为0，而由于根大(指大于 $2^p$) ，那么子节点小，到了子节点到子节点的边异或值为 $x$，到了子节点的子节点异或值为 $2^p$ ，如此循环往复，所有值一定 $\leq 2^p$

#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef unsigned long long ull;
#define x first
#define y second
#define pb push_back
#define mkp make_pair
#define endl "\n"
using namespace std;
const int N = 1 << 18;
int n, p;
vector<PII> edge[N];
int ans_edge[N], ans_node[N], tot;

void dfs(int u, int fa){
	for(auto v: edge[u]){
		if(v.x == fa) continue;
		if(ans_node[u] & n){
			ans_node[v.x] = ++tot;
			ans_edge[v.y] = tot + n;
		}
		else{
			ans_edge[v.y] = ++tot;
			ans_node[v.x] = tot + n; 
		}
		dfs(v.x, u);
	}
}

int main(){
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int T;
	cin >> T;
	while(T--){
		tot = 0;
		cin >> p;
		n = 1 << p;
		for(int i = 1; i < n; i++){
			int a, b;
			cin >> a >> b;
			edge[a].pb({b, i});
			edge[b].pb({a, i});
		}
		ans_node[1] = 1 << p;
		dfs(1, -1);
		cout << 1 << endl;
		for(int i = 1; i <= n; i++)
			cout << ans_node[i] << " ";
		cout << endl;
		for(int i = 1; i <= n - 1; i++)
			cout << ans_edge[i] << " ";
		cout << endl;
		for(int i = 1; i <= n; i++)
			edge[i].clear();
	}
    return 0;
}

Round #789 div2

D. Tokitsukaze and Meeting ( $\color{#AAF}{1700}$ )

DP + 行列分开计算贡献

题意

往 $n*m$ 矩阵左上角里塞 0 和 1, $m$ 列的元素前往下一行第1列, 依次后移, 询问每一次行和列中有多少个行和列里有 $1$

数据范围
$n*m\leq 10^6$

思路

行列分开考虑.
对于列, 进入 0 答案不变, 进入 1 如果第一列此时没有元素为1, 列答案++
对于行, 答案显然与 i - m 的行答案有关系, 相当于新加入了一行, 如果这行中有 1, 则行答案++, 具体实现见代码

#include<bits/stdc++.h>
#define pb push_back
#define endl "\n"
using namespace std;

int main(){
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int T;
	cin >> T;
	while(T--){
		int n, m;
		cin >> n >> m;
		string s;
		cin >> s;
		s = " " + s;
		vector<int> dp(n * m + 1, 0), ans(n * m + 1, 0);
		int cnt_col = 0, last = -0x3f3f3f3f;
		for(int i = 1; i <= n * m; i++){
			if(s[i] == '1'){
				bool fl = false;
				for(int j = i - m; j > 0 && !fl; j -= m)
					if(s[j] == '1')
						fl = true;
				if(!fl)
					cnt_col++;
				last = i;
			}
			dp[i] = dp[max(i - m, 0)] + ((i - last < ) ? 1 : 0);
			ans[i] = dp[i] + cnt_col;
		}
		for(int i = 1; i <= n * m; i++)
			cout << ans[i] << " ";
		cout << endl;
	}
    return 0;
}

Round #795 div2

D. Max GEQ Sum ($\color {#AAF}{1800}$)

题意转换, 单调栈, 前缀和, 最值查询

题意

给了一个长度为 $n$ 的数组 $a$, 询问该数组是否满足任意连续子序列 $[i, j]$ 满足:

\[max(a_i, a_{i+1},\cdots , a_j) \geq a_i + a_{i + 1} + \cdots + a_j \]

数据范围
$1\leq n \leq 2 * 10^5$
$-10^9\leq a_i \leq 10^9$

思路

题意转换: 实际询问从 $a_i$ 向两边扩展, 在未达到更新最大值的位置 $[l,r]$, 考虑一般情况下, 前缀和 $pre[r] - pre[l - 1] > a[i]$ 是否成立
以上转换, 可以把问题拆分多个问题空间的不重不漏的子集.
显然需要用单调栈\笛卡尔树 求出左右两边大于 $a_i$ 的第一个下标分别记为 $[L,R]$
则第一点的式子转化为是否存在 $l,r(L<l<i, i< r<R)$ 满足 $sum[l, i -1] + sum[i + 1, r] + a[i] > a[i]$.
即 $sum[l, i-1] + sum[i+1, r] > 0$ , 仔细观察发现等式只需要只要其中一个和大于 $0$ 就能满足了
故问题转化为求是否 $max{sum[l, i-1]} > 0 \; or\; max{sum[i+1,r]} > 0$
实际代码形式: querysuf(L+1, i-1) - suf[i] > 0 || querypre(i + 1, R - 1) - pre[i] > 0 , 时间复杂度为 $O(nlogn)$

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef unsigned long long ull;
typedef double db;
#define arr(x) (x).begin(),(x).end()
#define x first
#define y second
#define pb push_back
#define mkp make_pair
#define endl "\n"
using namespace std;
const int N = 2e5 + 10, M = 19;
const ll INF = -2e18;
ll stk[N], L[N], R[N], n, a[N], s[N], suf[N];
ll st1[N][M], st2[N][M];

void init(){
	for(int i = 0; i < M; i++)
		for(int j = 1; j + (1 << i) - 1 <= n; j++)	// 区间长度、右端点-1
			if(!i)
				st1[j][i] = s[j];
			else
				st1[j][i] = max(st1[j][i - 1], st1[j + (1 << (i - 1))][i - 1]);
	for(int i = 0; i < M; i++)
		for(int j = 1; j + (1 << i) - 1 <= n; j++)	// 区间长度、右端点-1
			if(!i)
				st2[j][i] = suf[j];
			else
				st2[j][i] = max(st2[j][i - 1], st2[j + (1 << (i - 1))][i - 1]);
}

ll querypre(int l, int r){
	if(l > r) return INF;
	int len = r - l + 1;
	int k = log(len) / log(2);
	return max(st1[l][k], st1[r - (1 << k) + 1][k]);	// 查询处记得+1
}

ll querysuf(int l, int r){
	if(l > r) return INF;
	int len = r - l + 1;
	int k = log(len) / log(2);
	return max(st2[l][k], st2[r - (1 << k) + 1][k]);	// 查询处记得+1
}

int main(){
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int T;
	cin >> T;
	while(T--){
		cin >> n;
		suf[n + 1] = 0;
		for(int i = 1; i <= n; i++){
			cin >> a[i];
			s[i] = s[i - 1] + a[i];
		}
		for(int i = n; i; i--)
			suf[i] = suf[i + 1] + a[i];
		init();
		int top = 0;
		stk[0] = 0;
		for(int i = 1; i <= n; i++){
			while(top && a[stk[top]] <= a[i]) top--;
			L[i] = stk[top];
			stk[++top] = i;
		}
		top = 0;
		stk[0] = n + 1;
		for(int i = n; i >= 1; i--){
			while(top && a[stk[top]] <= a[i]) top--;
			R[i] = stk[top];
			stk[++top] = i;
		}
		bool fl = true;
		for(int i = 1; i <= n; i++){
			int l = L[i] + 1, r = R[i] - 1;
			if(querysuf(l, i - 1) - suf[i] > 0 || querypre(i + 1, r) - s[i] > 0){
				fl = false;
				break;
			}
		}
		fl ? cout << "YES\n" : cout << "NO\n";
	}
    return 0;
}

Round #801 div2

C. Zero Path ( $\color{#AAF}{1700}$ )

方格dp、思维

题意

询问在大小为 $(n, m)$ 的方格中，每个格子上值为 $-1$ 或 $1$，是否存在一条从 $(1,1)$ 到 $(n, m)$ 的路径，满足路径和为 $0$

数据范围
$1\leq n,m \leq 1000$

思路

这个题很重视观察性质。
如果 $n + m$ 为偶数，则最后一定经过奇数个格子，此时无解。那么一定经过偶数个格子。
明显可以通过 dp 预处理出到达每个格子的最大值和最小值。如果 $dp[n][m]$ 的 $[最小值，最大值]$ 包含 $0$ 则有解，否则无解，证明：
- 如果不包含显然无解。证明包含一定有解。
- 因为经过偶数个格子，最后的和一定是偶数，（奇数-奇数，偶数-偶数）
- 如果进行一次调整让和变化，一定是 $2,0,-2$ 。因为本来和就是偶数，所以只要区间包含 0，一定可以调整到和为 0，证毕。
时间复杂度 $O(n*m)$ ，代码上还需要一些细节。一道不错的题。

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef unsigned long long ull;
typedef double db;
#define arr(x) (x).begin(),(x).end()
#define x first
#define y second
#define pb push_back
#define endl "\n"
using namespace std;
/*----------------------------------------------------------------------------------------------------*/
const int N = 1010;
int n, m;
int g[N][N], dp[N][N];

int main() {
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int T;
    cin >> T;
    while (T--) {
        cin >> n >> m;
        auto dp = Vector<int>(2, n + 2, m + 2);
        auto g = Vector<int>(n + 1, m + 1);
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= m; j++)
                cin >> g[i][j];
        if ((n + m - 1) & 1) {
            cout << "NO\n";
            continue;
        }
        for (int i = 1; i <= m; i++) {
            dp[0][0][i] = 1e9;
            dp[1][0][i] = -1e9;
        }
        for (int i = 1; i <= n; i++) {
            dp[0][i][0] = 1e9;
            dp[1][i][0] = -1e9;
        }
        dp[0][1][1] = dp[1][1][1] = g[1][1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if(i == 1 && j == 1) continue;
                dp[0][i][j] = g[i][j] + min(dp[0][i - 1][j], dp[0][i][j - 1]);
                dp[1][i][j] = g[i][j] + max(dp[1][i - 1][j], dp[1][i][j - 1]);
            }
        }
        bool fl = false;
        // cout << dp[0][n][m] << " " << dp[1][n][m] << endl;
        if (dp[0][n][m] <= 0 && dp[1][n][m] >= 0)
            fl = true;
        fl ? cout << "YES\n" : cout << "NO\n";
    }
    return 0;
}

Round #802 div2

C. Helping the Nature ( $\color{#AAF}{1700}$ )

差分、构造

题意

给了长度为 $n$ 数组 $a$，可以进行三种操作：

对任意前缀所有元素 $-1$ .
对任意后缀所有元素 $+1$ .
对全部元素 $=1$ .

询问最少经过多少次操作可以将所有元素置 $0$

数据范围
$1\leq n \leq 200000$
$1\leq a_i \leq 10^9$

思路

由于是区间操作，不妨用差分来思考
构造差分数组 b[i] = a[i] - a[i - 1], 目标状态 $b[i],\; i\leq n$ 全为 $0$
对于三种操作，等价于对差分数组：
1. b[1]--, b[i>1]++
2. b[n + 1]++, b[i<=n]--
3. b[1]++
所以先将 $2 \leq i \leq n$ 的所有 b[i] 全部设为 $0$，最后将 $b[1] $ 置 $0$，将 $b[1]$ 置 $0$ 三种操作都可以，贪心取最划算的即可。
时间复杂度 $O(n)$

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef unsigned long long ull;
typedef double db;
#define arr(x) (x).begin(),(x).end()
#define x first
#define y second
#define pb push_back
#define endl "\n"
using namespace std;
/*----------------------------------------------------------------------------------------------------*/

int main() {
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        vector<ll> a(n + 2, 0), b(n + 2, 0);
        ll ans = 0;
        for (int i = 1; i <= n + 1; i++) {
            if (i <= n)
                cin >> a[i];
            b[i] = a[i] - a[i - 1];
        }
        for (int i = 2; i <= n; i++) {
            ans += abs(b[i]);
            if (b[i] > 0) {
                b[n + 1] += b[i];
                b[i] = 0;
            }
            else {
                b[1] += b[i];
                b[i] = 0;
            }
        }
        cout << ans + max(abs(b[1]), abs(b[n + 1])) << endl;
    }
    return 0;
}

Education Round

Round 42 (Rated for Div. 2)

E. Byteland, Berland and Disputed Cities ( $\color{#FA8}{2200}$ )

贪心

题意

给了 $n\,(2\leq n\leq 2*10^5)$ 个点，坐标 $-10^9 \leq x \leq 10^9$ 。每个点属于 P,B,R 其中一个。

询问在 {P,B} 点集中连接所有点和 {P,R} 点集中连接所有点，两者加起来的花费最小值。

思路

一点点考虑发现是个贪心分类讨论题。
对于没有 P 点存在，答案很显然。
如果两个 P 点中夹杂 B/P。对于这一段连接方式有两种。
- 相邻两点不管什么颜色直接连接。
- 先连接这一段的两个端点 P，这样在上一种连接方式下，可以扣除中间跨度最大的相邻点的连线，这样可能会更优。
时间复杂度 $O(n)$。

Solution

CF962E-评测记录

Round 47 (Rated for Div. 2)

这场vp, 打的很烂, D 题读漏条件, B 题贪错方向

B. Minimum Ternary String ( $\color{#8DB}{1400}$ )

贪心
题意

给定长度为 $n(1\leq n\leq 10^5)$ 的串, 只有 $0,1,2$ 组成, 相邻 $0$ 和 $1$ 可以互换, 相邻 $1$ 和 $2$ 可以互换, 询问任意互换次数后整个串的最小字典序

思路

主要把握住题目条件, 发现 1 可以与 0 和 2 换, 所以不会有 1 在 2 之后, 第一个 2 之前的 0 在最前面, 之后相对顺序不变

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef unsigned long long ull;
typedef double db;
#define arr(x) (x).begin(),(x).end()
#define x first
#define y second
#define pb push_back
#define mkp make_pair
#define endl "\n"
using namespace std;

int main(){
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	string s;
	cin >> s;
	int n = s.size();
	queue<int> q1, q2;
	bool fl = false;
	int pos = 0, cnt1 = 0;
	for(int i = 0; i < n; i++){
		if(s[i] == '2'){
			if(!fl)
				pos = i;
			fl = true;
		}
		else if(s[i] == '1')
			cnt1++;
	}
	if(!fl){
		for(int i = 0; i < n - cnt1; i++)
			cout << 0;
		for(int i = 0; i < cnt1; i++)
			cout << 1;
	}
	else{
		int cnt0 = 0;
		for(int i = 0; i < pos; i++){
			if(s[i] == '0')
				cnt0++;
		}
		for(int i = 0; i < cnt0; i++)
			cout << 0;
		for(int i = 0; i < cnt1; i++)
			cout << 1;
		for(int i = pos; i < n; i++){
			if(s[i] != '1')
				cout << s[i];
		}
	}
    return 0;
}

C. Annoying Present ( $\color{#AAF}{1700}$ )

贪心---货仓选址模型利用, 注意开 long double

题意

输入 $n,m$ , 表示长度为 $n$ 的数组, $m$ 次操作, 每次操作有 $x$ 和 $d$, 每次操作选择一个下标 $i$, 对数组所有元素加上 $x + d * |i-j|$, 询问最终操作后数组平均值最大值

数据范围

$1\leq n, m \leq 10^5$
$-10^3\leq x_i,d_i\leq 10^3$

思路

平均值最大 -> 数组和最大, 负数影响最小, 正数影响最大.
$x$ 对和的贡献固定, 考虑距离的贡献, 由货仓选址模型可知, 距离和最小的选点应在中点, 反之最大的点应在边缘点, 之后便可求解该题
观察数据范围, 要开 long double

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef double db;
#define arr(x) (x).begin(),(x).end()
#define x first
#define y second
#define pb push_back
#define mkp make_pair
#define endl "\n"
using namespace std;

int main(){
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int n, m;
	cin >> n >> m;
	long double sum = 0;
	long double tot1 = 0, tot2 = 0;
	int mid = (n + 1) / 2;
	for(int i = 1; i <= n; i++){
		tot1 += abs(i - mid);
		tot2 += i - 1;
	}
	while(m--){
		long double x, d;
		cin >> x >> d;
		sum += (long double)n * x;
		if(d < 0)
			sum += d * tot1;
		else
			sum += tot2 * d;
	}
	cout << fixed << setprecision(7) << sum / n << endl;
    return 0;
}

D. Relatively Prime Graph ( $\color{#AAF}{1700}$ )

构造, 边上两点编号互质, 图要求连通

题意

给定一个图, 询问是否能构造出 $n$ 个点, $m$ 条边的连通图, 任意边两端点编号互质

数据范围
$1\leq n,m\leq 100000$

思路

观察数据范围, 最多只有 $m, 1000000$ 条边, 对于每一个数与其互质小于它的数字个数为 $\Phi (x)$, 累加到 $600$ 左右时, 已经大于了 $10^5$
故可以暴力用 gcd() 判断两点互质来连边
记得是连通图, 即 $m > n - 1$

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef double db;
#define arr(x) (x).begin(),(x).end()
#define x first
#define y second
#define pb push_back
#define mkp make_pair
#define endl "\n"
using namespace std;

ll gcd(ll a, ll b){
	return b ? gcd(b, a % b) : a;
}

int main(){
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int n, m;
	scanf("%d%d", &n, &m);
	vector<PII> ans;
	int now = 1, cnt = 0;
	if(m < n - 1){
		printf("Impossible\n");
		return 0;
	}
	while(cnt < m && now <= n){
		if(now == 1){
			for(int i = 2; i <= n && cnt < m; i++){
				ans.pb({now, i});
				cnt++;
			}
			now++;
			continue;
		}

		for(int i = now + 1; i < 2 * now && cnt < m; i++){
			if(gcd(i, now) != 1) continue;
			for(int j = 0; i + j * now <= n && cnt < m; j++){
				int v = i + j * now;
				ans.pb({now, v});
				cnt++;
			}
		}
		now++;
	}
	if(cnt < m)
		printf("Impossible\n");
	else{
		printf("Possible\n");
		for(int i = 0; i < m; i ++)
			printf("%d %d\n", ans[i].x, ans[i].y);
	}
    return 0;
}

E. Intercity Travelling ( $\color{#F9F}{2000}$ )

组合数, 递推, 期望

题意

你要从 $0~n$ ，有 $n$ 个站点 $(1~n)$，每个站点都有 $1/2$ 的几率有休息点。你连续坐 $k$ 站时，每两站间的疲劳值为 $a_1,a_2……a_k$，
如果第 $k$ 站有休息点，那么你可以在此处休息，然后接下来的站点的疲劳值又从 $a_1$ 开始。求 $p(疲劳值的期望)*2^(n-1)$。

数据范围
$1\leq n,a_i\leq 10^6$

思路

我们要求的其实是疲劳值之和, 直接算肯定不好搞, 要按贡献来算, 有两种思路, 考虑每两点之间的答案贡献, 考虑每个 $a_i$ 的贡献, 前者请参考官方题解
计算每个 $a_i$ 的贡献其实是求每个 $a_i$ 的出现次数
考虑 $a_1$ , 由于 $0$ 点的特殊性, $0->1$ 一定有一个 $a_1$, 无论后面怎么走, 有 $2^{n-1}$ 次, 考虑后面的 $n$ 个点相邻两点 x 和 y, 一定是 x 休息, 其他点无所谓(但不考虑终点的休息)有 $(n-1)*2^{n-2}$
同样考虑 $a_2$, 对于 $0$ 点特殊考虑, $0->1->2$, 2 及以后的店怎么搞无所谓, 有 $2^{n-2}$ 次, 同样和前面一样, x, y, z 三个点, 一定是 x 休息, y 不休息, 其他点无所谓, 有 $(n-2)*2^{n-3}$
所以对于任意 $a_i$ 出现次数为 $2^{n-i} + (n-i)*2^{n-i-1}$

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef double db;
#define arr(x) (x).begin(),(x).end()
#define x first
#define y second
#define pb push_back
#define mkp make_pair
#define endl "\n"
using namespace std;
const int mod = 998244353, N = 1e6 + 10;
ll mi[N];

int main(){
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	mi[0] = 1;
	int n;
	cin >> n;
	for(int i = 1; i <= n; i++)
		mi[i] = mi[i - 1] * 2 % mod;
	ll ans = 0;
	for(int i = 1; i <= n; i++){
		ll a;
		cin >> a;
		ans = (ans + a * (mi[n - i] + 1ll * (n - i) * mi[n - i - 1] % mod) % mod) % mod;
	}
	cout << ans << endl;
    return 0;
}

Round 84 (Rated for Div. 2)

D. Infinite Path ( $\color{#FA8}{2200}$ )

置换环、数论

题意

定义排列乘法 $c=a\times b$ , $c[i]=b[a[i]]$ 。自然有排列的幂次 $p^k = p*p*\cdots *p$。

给定在长度为 $n\,(1\leq n \leq 2 \times 10^5)$ 的排列 $p$ 。和每个点的颜色 $c$ 。询问最小的幂次 $k$ 能存在一个
$i$ 使得 $i,p[i],p[p[i]],p[p[p[i]]],\dots$ 都是同一种颜色。

思路

读完题目很容易联想置换环这个东西，每个点 $i$ 向 $p[i]$ 连边，会形成若干个环。
对于每个环的内部，经过环的长度幂次 $len$ 一定能存在一个 $i$ 。
还有更快的方式就是，经过环的因子次 $L$ 变换以后，会分成 $L$ 个长度为 $len / L$ 的小环。如果存在一个小环所有点颜色相同则 $L$ 合法。
- 给一个样例 p: 6 5 4 2 1 3 color: 1 1 1 3 4 5 答案为 $3$ 。
解法就是找出所有的环，再暴力枚举环长度的所有因子，来检验是否合法，简单分析复杂度是够的。

Solution

评测记录

Round 115 (Rated for Div. 2)

这场是vp的，4题138罚时，performance在 $1835$

E. Staircase ( $\color{#FA8}{2100}$ )

经典放格计数, DP 预处理, 修改只考虑单点对答案的贡献

题意

一张 $n * m$ 的图，有两种楼梯形，L 和 7 形，即向下向右和向右向下这样无限重复，单点和横着的两个点和竖着的两个点也算，有 $q$ 个询问，每次将每个点的权值异或 $1$ ，如果某个点的值为 $0$ ，那么这个点就不能用，再询问贡献。

数据范围
$1\leq n \leq 1000$
$1\leq m \leq 1000$
$1\leq q \leq 10^4$

思路

先处理所有格子都 free 的所有方案数，用 dp 来做
- dp[i][j][0] 表示该点作为左下角的方案数、dp[i][j][1] 表示该点作为右下角的方案数
- 所有状态初始化为 1，状态转移：dp[i][j][0] += dp[i - 1][j][1], dp[i][j][1] += dp[i][j - 1][0]
- 以每个格子结尾对答案的贡献就是 dp[i][j][0] + dp[i][j][1] - 1
然后再考虑对于每个询问来处理，每次询问给出 (x,y) 点，这里有一个处理技巧：只考虑这个点对答案的贡献
从该点出发（先假定这个格子 free），往上和往下最多能走的合法格子数，相乘-1就是贡献，当然注意有两种走法

自己想法

不会对每个询问贡献单独算，不太会处理所有格子free的方案数

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef unsigned long long ull;
#define x first
#define y second
#define pb push_back
#define mkp make_pair
#define endl "\n"
using namespace std;
const int N = 1010;
int dp[N][N][2], sta[N][N];

int main(){
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int n, m, q;
	cin >> n >> m >> q;
	ll ans = 0;
	for(int i = 1; i <= n; i++){
		for(int j = 1; j <= m; j++){		// 0左下角
			sta[i][j] = 1;
			dp[i][j][0] = dp[i][j][1] = 1;
			dp[i][j][0] += dp[i - 1][j][1];
			dp[i][j][1] += dp[i][j - 1][0];
			ans += dp[i][j][0] + dp[i][j][1] - 1;
		}
	}
	int dx[4] = {0, -1, 1, 0}, dy[4] = {-1, 0, 0, 1};		// 左、上、下、右
	while(q--){
		int x, y;
		cin >> x >> y;
		int sign = 1, term = 0;
		if(sta[x][y]) sign = -1;
		else term = 1, sta[x][y] = 1;
		int up = 0, down = 0, dir = 0;
		ll d = 0;
		int nx = x, ny = y;
		while(sta[nx][ny]){
			up++;
			nx = nx + dx[dir];
			ny = ny + dy[dir];
			dir ^= 1;
		}
		nx = x, ny = y, dir = 2;
		while(sta[nx][ny]){
			down++;
			nx = nx + dx[dir];
			ny = ny + dy[dir];
			dir = 5 - dir;
		}
		d += 1ll * up * down;
		up = down = 0;
		nx = x, ny = y, dir = 1;
		while(sta[nx][ny]){
			up++;
			nx = nx + dx[dir];
			ny = ny + dy[dir];
			dir ^= 1;
		}
		nx = x, ny = y, dir = 3;
		while(sta[nx][ny]){
			down++;
			nx = nx + dx[dir];
			ny = ny + dy[dir];
			dir = 5 - dir;
		}
		d += 1ll * up * down;
		d -= 1;
		sta[x][y] = term;
		ans += d * sign;
		cout << ans << endl;
	}
    return 0;
}

Round 116 (Rated for Div. 2)

D. Red-Blue Matrix ( $\color{#F87}{2400}$ )

题意

给了一个 $n*m$ 的矩阵，每个元素有一个值，现在要把矩阵的行染成蓝色或红色（必须两个颜色都有），染完后将矩阵切成左右两个矩阵，切割行为 $k$
左边矩阵红色元素都比蓝色元素大，右边矩阵蓝色元素都比红色元素

数据范围
$2\leq n,m \leq 5\times 10^5\; , n*m \leq 1e6$
$a_{ij} \leq 10^6$

思路

首先无论分割点在哪里，第一列永远要被考虑，如果将行按第一列元素大小排序，那么永远只有前缀行染成蓝色
然后枚举切割点和染色行检验合法性，要预处理顶点出发的子矩阵最值做到O（1）查询

自己想法

不知道第一列元素的重要性，甚至看了题解半天没反应出来怎么预处理子矩阵最值

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
#define x first
#define y second
#define pb push_back
#define mkp make_pair
#define endl "\n"
using namespace std;
typedef std::pair<int, int> PII;
typedef std::pair<vector<int>, int> PLL;
int n, m;

bool cmp(PLL& a, PLL& b){
    return a.x[1] < b.x[1];
}

int main(){
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int T;
    cin >> T;
    while(T--){
        cin >> n >> m;
        vector<PLL> a(n + 1, {vector<int>(m + 1, 0), 0});
        for(int i = 1; i <= n; i++){
            a[i].y = i;
            for(int j = 1; j <= m; j++)
                cin >> a[i].x[j];
        }
        sort(a.begin() + 1, a.end(), cmp);
        vector<vector<int>> lmx(n + 2, vector<int>(m + 2, 0));
        vector<vector<int>> rmx(n + 2, vector<int>(m + 2, 0));
        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= m; j++){
                lmx[i][j] = a[i].x[j];
                lmx[i][j] = max(lmx[i][j], lmx[i - 1][j]);
                lmx[i][j] = max(lmx[i][j], lmx[i][j - 1]);
            }
        }
        for(int i = n; i >= 1; i--){
            for(int j = m; j >= 1; j--){
                rmx[i][j] = a[i].x[j];
                rmx[i][j] = max(rmx[i][j], rmx[i + 1][j]);
                rmx[i][j] = max(rmx[i][j], rmx[i][j + 1]);
            }
        }
        vector<vector<int>> lmin(n + 2, vector<int>(m + 2, 1e9));
        vector<vector<int>> rmin(n + 2, vector<int>(m + 2, 1e9));
        for(int i = 1; i <= n; i++){
            for(int j = m; j >= 1; j--){
                rmin[i][j] = a[i].x[j];
                rmin[i][j] = min(rmin[i][j], rmin[i - 1][j]);
                rmin[i][j] = min(rmin[i][j], rmin[i][j + 1]);
            }
        }
        for(int i = n; i >= 1; i--){
            for(int j = 1; j <= m; j++){
                lmin[i][j] = a[i].x[j];
                lmin[i][j] = min(lmin[i][j], lmin[i + 1][j]);
                lmin[i][j] = min(lmin[i][j], lmin[i][j - 1]);
            }
        }
        PII ans = {0, -1};
        for(int k = 1; k < m; k++){
            for(int blue = 1; blue < n; blue++){
                PII lb = {blue, k}, rb = {blue, k + 1};
                PII lr = {blue + 1, k}, rr = {blue + 1, k + 1};
                if(lmx[lb.x][lb.y] < lmin[lr.x][lr.y] && rmin[rb.x][rb.y] > rmx[rr.x][rr.y]){
                    ans = {blue, k};
                }
            }
        }
        if(!ans.x)
            cout << "NO\n";
        else{
            cout << "YES\n";
            string s(n, 'R');
            for(int i = 1; i <= ans.x; i++)
                s[a[i].y - 1] = 'B';
            cout << s << " " << ans.y << endl;
        }
    }
    return 0;
}

E. Arena ( $\color{#FA8}{2100}$ )

题意

有 $n$ 个人，每人有 $a_i$ 点生命值 ($a_i <= k$) ,每次每人会对其他所有人造成 $1$ 点伤害。
生命值低于 $1$ 的会死亡，给出 $n$ 和 $k$ ，问有多少种不同初始生命值情况会出现场上无人存活（没有赢家）
输出答案总数 $\mod 998244353$

数据范围
$2\leq n \leq 500$
$1\leq x \leq 500$

思路

观察数据范围，唯一有理做法就是 DP，复杂度大概在 $O(n^3)$ 左右
首先可以大致确定一个小阶段是进行的轮数，但并不一定用轮数作为一个dp的一个纬度，可能是其他与轮数相关的东西
询问剩余 $0$ 人，多少种不同初始生命值的方案数，这个集合可以由剩余 $0$ 人，遭受了 $j$ 次攻击的集合组成 ($0\leq j\leq x$)
状态表示： dp[i][j] 当前轮剩下 $i$ 个人，已经遭受 $j$ 次攻击的情况
考虑如何转移，遍历下一轮剩余的人数为 $k$，则被更新的状态是 dp[k][min(j + i - 1, x)]
状态转移：
- $dp[k][min(x, j + i - 1)] = dp[k][min(x, j + i - 1)] + dp[i][j] * C_i^{i - k} * (min(x, j + i - 1) - j) ^ {i-k}$
- $i$ 个人里面选 $i-k$ 个人死亡，死亡的 $i-k$ 个人里的生命值组成情况可以是 $[1, min(x, j + i - 1) - j]$ 范围。

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef unsigned long long ull;
#define x first
#define y second
#define pb push_back
#define mkp make_pair
#define endl "\n"
using namespace std;
const int N = 510, mod = 998244353;
int n, x;
ll dp[N][N];       
// dp[i][j] 当前轮剩下 i 个人，已经遭受 j 次攻击的情况
// 下一轮k个人存活，dp[k][min(x, j + i - 1)] += dp[i][j] * C[i][i - k] * (min(x, j + i - 1) - j) ^ (i-k)
ll c[N][N];        // c[a][b] -> C_a^b

void init(){
    for(int i = 0; i < N; i++)
        for(int j = 0; j <= i; j++)     // b <= a
            if(!j) 
                c[i][j] = 1;
            else
                c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;        // % mod
}

ll qmi(ll a, ll k, int mod){
    ll res = 1;
    while(k){
        if(k & 1)
            res = res * a % mod;
        a = a * a % mod;
        k >>= 1;
    }
    return res;
}

void add(ll& a, ll t){
    a = (a + t) % mod;
}

int main(){
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> n >> x;
    init();
    dp[n][0] = 1;
    for(int i = n; i >= 1; i--){
        for(int j = 0; j < x; j++){
            if(!dp[i][j]) continue;
            int nxt = min(x, j + i - 1);
            for(int k = i; k >= 0; k--){
                add(dp[k][nxt], dp[i][j] * c[i][i - k] % mod * qmi(nxt - j, i - k, mod) % mod);
            }
        }
    }
    ll ans = 0;
    for(int i = 0; i <= x; i++)
        add(ans, dp[0][i]);
    cout << ans << endl;
    return 0;
}

Round 117 (Rated for Div. 2)

E. Messages ( $\color{#F9F}{2000}$ )

题意

现有 $n$ 名学生，老师希望学生 $i$ 阅读消息 $m_i$ 。
老师可以发布 $t$ 条消息，但每个学生只会随机选择其中 $k_i$ 条进行阅读，发布信息数量大于 $k_i$ 条时，随机选择 $k_i$ 条信息阅读。
请给出一种发布信息的方案，使得在期望条件下，有尽可能多的学生 $i$ 阅读了对应的信息 $m_i$ 。

数据范围

$1\leq n\leq 2*10^5$
$1\leq k_i \leq 20$
$1\leq t \leq 2*10^5$

思路

从数据范围入手，$k_i$ 最多只有20个，尝试一下暴力，进行分类讨论
单独看每个信件被阅读到的期望贡献，答案就是 $t$ 个信件期望相加，对于一个学生阅读信件数 $k_i$ 来说，被期望阅读该信件，则该信件期望增加 $\frac{min(k_i, t)}{t}$
在不考虑 $t$ 的情况下，遍历每个学生，可以获得所有信件的期望，如果 $t$ 能够确定，那么我们只需要取期望前 $t$ 大的信件就是最优的。
如果 $t > 20$，由上可知对于每个信件的期望分母一直变大，由于 $k_i<20$，所以随着 $t$ 变大，最后期望变小，所以毫无意义。
现在考虑 $t \leq 20$，由于随着 $t$ 变大，尽管看似单个信件的期望在变小，信件数量增加，总期望变化不确定，而由于 $t$ 最多只有 $20$，我们就直接暴力枚举 $t$ 的情况，取最优解即可。
时间复杂度: $O(20 * 2e5 * log(2e5))$

Solution

#include<bits/stdc++.h>
#define pb push_back
#define endl "\n"
using namespace std;
const int N = 2e5;
PII pro[N + 10];
bool mp[N + 10];

bool cmp(PII a, PII b){
    return a.x > b.x;
}

int main(){
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, cnt = 0;
    cin >> n;
    vector<PII> a(n);
    for(int i = 0; i < n; i++){
        cin >> a[i].x >> a[i].y;
        if(!mp[a[i].x])
            cnt++;
        mp[a[i].x] = true;
    }
    double mx = 0;
    vector<int> ans;
    for(int k = 1; k <= min(20, cnt); k++){
        for(int i = 1; i <= N; i++) 
            pro[i] = {0, i};
        for(int i = 0; i < n; i++)
            pro[a[i].x].x += min(a[i].y, k);
        sort(pro + 1, pro + 1 + N, cmp);
        double res = 0;
        vector<int> temp;
        for(int i = 1; i <= k; i++){
            res += pro[i].x;
            temp.pb(pro[i].y);
        }
        res /= k;
        if(res > mx){
            mx = res;
            ans = temp;
        }
    }
    cout << ans.size() << endl;
    for(auto t: ans)
        cout << t << " ";
    cout << endl;
    return 0;
}

Round 118 (Rated for Div. 2)

D. MEX Sequences ( $\color{#F9F}{1900}$ )

题意

给定长度 $n$ 的数组 $a$，其中 $0\leq a_i \leq n$ 询问合法子序列的个数，合法子序列的定义，对于这个序列的每一个前缀，最后一个数和前缀的 $MEX$ 差值的绝对值不大于 $1$。
答案 $\mod 998244353$ 。

数据范围
$1\leq n \leq 5*10^5$
$0\leq a_i \leq n$

思路

多画几次可以感觉出大概是个 状态机DP
合法序列的状态只有以下几种：
1. 0 1 1 2 2 3 4 5
2. 0 2 2 0 0 2 0 2
3. 由第一种变为第二种 0 1 2 2 4 2 4 2 4
DP阶段为从左往右的数组下标
状态表示： f[i][0] 表示 MEX 为 $i$ 状态为上述第一种的情况， f[i][1] 表示 MEX 为 $i$ 状态为上述第二种的情况
状态转移： 设 i = a[i_]
- f[i + 1][0] += f[i + 1][0] + f[i][0]，选或不选 + 递增连接。
- f[i + 1][1] += f[i + 1][1]，在第二种情况选或不选
- if i > 0, f[i - 1][1] += f[i - 1][1] + f[i - 1][0]，第二种情况选或不选 + 将第一种情况变成第二种情况
答案统计 $\Sigma_{i = 0}^n f[i][0] + f[i][1] \mod 998244353$

Solution

#include<bits/stdc++.h>
#define endl "\n"
using namespace std;
const int mod = 998244353;

void add(ll &a, ll b){
    a = (a + b) % mod;
}

int main(){
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int T;
    cin >> T;
    while(T--){
        int n;
        cin >> n;
        vector<vector<ll>> f(n + 2, vector<ll>(2, 0));
        vector<int> a(n, 0);
        for(int i = 0; i < n; i++)
            cin >> a[i];
        f[0][0] = 1;
        for(int i_ = 0; i_ < n; i_++){      
            int i = a[i_];
            add(f[i + 1][0], f[i + 1][0]);
            add(f[i + 1][0], f[i][0]);
            if(i > 0)
                add(f[i - 1][1], f[i - 1][1] + f[i - 1][0]);
            add(f[i + 1][1], f[i + 1][1]);
        }
        ll ans = 0;
        for(int i = 0; i <= n; i++){
            ans = (ans + f[i][0] + f[i][1]) % mod;
        }
        add(ans, mod - 1);
        cout << ans << endl;
    }
    return 0;
}

Round 119 (Rated for Div. 2)

D. Exact Change ( $\color{#F9F}{2000}$ )

题意

有 $3$ 种货币，每个价值 $1,2,3$ 元，给出 $n$ 个商品的价值，每个价值为 $a_i$ ，询问最少的货币数能够准确买下所有商品

思路

此题毒瘤分类讨论，由于最大面值为 $3$ ，所以 $3$ 元货币尽可能多，贪心地对最贵商品进行讨论，同时价值相同商品无意义排序去重。
设最大商品价值为 x，对 $x \mod 3$ 模数讨论。
模数为 $0$，其他商品如果有模数为 $1$ 或者 $2$ ，用一张 3 元换成 1 + 2，可以凑出所有方案，否则答案为 x / 3
模数为 $1$，可以选择 x / 3 - 1 张 3 元 + 2 张 2 元或者 x / 3 张 3 元 + 1 张 1 元，这是最少的答案为 x / 3 + 1
- 对于前者，不能凑出价值 1 元和 x - 1 元的商品
- 对于后者，不能凑出模数为 $2$ 元的商品
- 所以如果上述两个情况同时成立，ans++
模数为 $2$，最少的方案是 x / 3 张 3 元 + 1 张 2元 (x / 3 + 1)。如果存在模数为 $1$ 的商品，将一张 3 元拆成 1 + 2即可，ans++

Solution

#include<bits/stdc++.h>
#define endl "\n"
using namespace std;
const int INF = 1e9;

int main(){
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int T;
    cin >> T;
    while(T--){
        int n;
        cin >> n;
        vector<int> a(n, 0);
        for(int i = 0; i < n; i++)
            cin >> a[i];
        sort(a.begin(), a.end());
        a.erase(unique(a.begin(), a.end()), a.end());
        n = a.size();
        vector<int> c(3, 0);
        if(n == 1){
            cout << a[0] / 3 + (a[0] % 3 != 0) << endl;
            continue;
        }
        for(int i = 0; i < n - 1; i++)
            c[a[i] % 3] ++;
        int tot = (a[n - 1] + 2) / 3;
        if(a[n - 1] % 3 == 1){
            if(c[2] && (a[0] == 1 || a[n - 2] == a[n - 1] - 1))
                tot ++;
        }
        else if(a[n - 1] % 3 == 2){
            if(c[1])
                tot ++;
        }
        else if(a[n - 1] % 3 == 0){
            if(c[1] || c[2])
                tot++;
        }
        cout << tot << endl;
    }
    return 0;
}

E. Replace the Numbers ( $\color{#F9F}{1900}$ )

题意

给一个数组初始为空，进行 $q$ 次操作，一个是向数组末尾插数，一个是将数组中所有的 x 替换乘 y

数据范围
$1\leq q \leq 5 * 10^5$
$1\leq x,y \leq 5 * 10^5$

思路

模拟一下，发现每次将 $x$ 向 $y$ 连边，统计最终值就是看 $x$ 连向的终点
换种说法，其实就是并查集的操作，而精妙在于如何处理中途插入
正难则反，倒着操作，遇见插入的时候就把 p[x] 放入答案，每次合并等于并查集合并 p[x] = p[y]
最后将答案逆序输出，时间复杂度 $O(n)$

Solution

#include<bits/stdc++.h>
#define pb push_back
#define endl "\n"
using namespace std;
const int N = 5e5 + 10;
int p[N];

struct Q{
    int op, x, y;
};

int main(){
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int m;
    cin >> m;
    vector<int> ans;
    vector<Q> q(m);
    for(int i = 1; i < N; i++) p[i] = i;
    for(int i = 0; i < m; i++){
        int op, x, y;
        y = 0;
        cin >> op;
        if(op == 1)
            cin >> x;
        else
            cin >> x >> y;
        q[i] = {op, x, y};
    }
    for(int i = m - 1; ~i; i--){
        auto [op, x, y] = q[i];
        if(op == 1)
            ans.pb(p[x]);
        else
            p[x] = p[y];
    }
    reverse(ans.begin(), ans.end());
    for(auto t: ans)
        cout << t << " ";
    cout << endl;
    return 0;
}

Round 120 (Rated for Div. 2)

E. Math Test ( $\color{#FA8}{2200}$ )

题意

有 $n$ 个人做 $m$ 道题，知道每个人做题的对错情况。每个人有一个预期得分 $x_i$ 和实际得分 $r_i$ 。$x_i$ 给定，而 $r_i$ 是该人做对题目的分数之和。定义 “惊喜度” 为每个人的 $∣x_i−r_i∣$ 之和。
请你构造出一个每道题的分数方案，使得：

分数是一个 $1∼m$ 的排列。
在所有的方案中，该方案的 “惊喜度” 最大。

数据范围
$1\leq n \leq 10$
$1\leq m \leq 10^4$
$0\leq x_i \leq \frac{m(m+1)}{2}$

思路

观察数据范围，$n\leq 10$，可以二进制枚举每个人的得分绝对值情况，拆绝对值
答案为 $\Sigma_{i=1}^n (c[i]*x[i] - c[i] * r[i])$
前半部分固定，想要答案最大，则后半部分的减数最小，那么对应答对次数小的题目应该获得更高的分数。
枚举不同 c[i] 情况，然后计算每个题目的答对次数（有负数），根据次数排序，从小到大赋值，更新答案即可。
这题时间复杂度比较玄学。按道理就是 $O(2^n*m + 2^n*m*logm)$，却跑的挺快。

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef unsigned long long ull;
#define x first
#define y second
#define pb push_back
#define mkp make_pair
#define endl "\n"
using namespace std;
const int N = 5e5 + 10;
int p[N];

struct Q{
    int op, x, y;
};

int main(){
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int m;
    cin >> m;
    vector<int> ans;
    vector<Q> q(m);
    for(int i = 1; i < N; i++) p[i] = i;
    for(int i = 0; i < m; i++){
        int op, x, y;
        y = 0;
        cin >> op;
        if(op == 1)
            cin >> x;
        else
            cin >> x >> y;
        q[i] = {op, x, y};
    }
    for(int i = m - 1; ~i; i--){
        auto [op, x, y] = q[i];
        if(op == 1)
            ans.pb(p[x]);
        else
            p[x] = p[y];
    }
    reverse(ans.begin(), ans.end());
    for(auto t: ans)
        cout << t << " ";
    cout << endl;
    return 0;
}

Round 125 (Rated for Div. 2)

E. Star MST ( $\color{#FA8}{2200}$ )

题意

给了一张无向完全图，点数 $n$ 和边权值范围 $k$，求合法图的数量 $\mod 998244353$，合法图的定义是，与 $1$ 号点连接的所有边边权和是 $MST$ 的大小。

数据范围
$2\leq n \leq 250$
$1\leq k \leq 250$

思路

不难看出，主要核心是 1 号点，并且 1 号点连接的边的边权一定是最小的 $n-1$ 个，否则不成立和为 $MST$ ，很容易证明
由数据范围看出，应该是个 DP 题目，然后就开始玄学，可知非中心边的边权在 [中心边边权最大值，k] 范围内。
DP阶段：加入图中的点数，方案数来源不同边的权值分配不同
状态表示： 根据最终答案是，$n$ 个点，边权最大值为 $k$ 的方案，状态定义为 dp[i][j], 选了 $i$ 个点，最大值为 $j$ 方案数
考虑如何转移，每加入一个新点，会产生 i - 1 条边，加入 i-z 个新点，其中新点定义不同对答案有贡献，贡献为 $C_{i-1}^{z-1}$ , 会产生 (z-1) * (i-z) + (i-z) * (i-z-1) / 2 条新边。
第二维更新，从小到大遍历，j 由 j-1 转移，这样新产生的边不管是中心边还是非中心边，范围都在 $[j, k]$ 之间
状态转移： $dp[i][j] = dp[i][j] + dp[z][j - 1] * C_{i-1}^{z-1} * (k-j+1)^{(z-1) * (i-z) + (i-z) * (i -z + 1) / 2}$，答案为 dp[n][k]
时间复杂度：$O(n^2k)$

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef unsigned long long ull;
#define x first
#define y second
#define pb push_back
#define mkp make_pair
#define endl "\n"
using namespace std;
const int N = 300, mod = 998244353;
ll dp[N][N];		// dp[i][j], 选了i个点，最大值为 j 方案数
int n, k;
// dp[i][j] = dp[z][j - 1] * c[i - 1][z - 1] * (k - j + 1)^((z - 1) * (i - z) + (i - z) * (i - z - 1) / 2)
// 1 <= z <= i，由dp[z][j - 1] 转移，需要乘上 i-1个点里选z-1个点作为已选择点，新加入的边数 i-z个点和z-1个点连，i-z个点互相连接，每条边的范围在[j,k]

int c[N][N];        

void init(){ 		// 递推预处理组合数
    for(int i = 0; i < N; i++)
        for(int j = 0; j <= i; j++)     // b <= a
            if(!j) 
                c[i][j] = 1;
            else
               c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;        // % mod
}

// 快速幂计算a^k
ll qmi(ll a, ll k, int mod){
	ll res = 1;
	while(k){
		if(k & 1)
			res = res * a % mod;
		a = a * a % mod;
		k >>= 1;
	}
	return res;
}

void add(ll &a, ll b){
	a = (a + b) % mod;
}

int main(){
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	dp[1][0] = 1;
	cin >> n >> k;
	init();
	for(int i = 1; i <= n; i++){
		for(int j = 1; j <= k; j++){
			for(int z = 1; z <= i; z++){
				// 按照推导的公式写就行
				add(dp[i][j], dp[z][j - 1] * c[i - 1][z - 1] % mod * qmi(k - j + 1, (z - 1) * (i - z) + (i - z) * (i - z - 1) / 2, mod) % mod);	
			}
		}
	}
	cout << dp[n][k] << endl;
    return 0;
}

Round 127 (Rated for Div. 2)

E. Preorder ( $\color{#FA8}{2100}$ )

题意

给一颗节点数为 $2^n - 1$ 满二叉树，点权为小写字母，根为 $1$, 可以交换每个节点的两颗子树，问最后对整个树来说会有多少种不同的先序遍历序列（字符串）。

思路

对于叶子节点，只有一种方案
对于非叶子节点，如果两个子树构成不同，该节点数方案为 2 * l * r，否则为 l * r
那么如何判断子树构成是否相同？
将所有子树调整为字典序最大或最小的情况，如 if(s[l] < s[r]) swap(s[l], s[r]), s[u] = " " + s[u] + s[l] + s[r]。
然后做一次 DFS 即可求解

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef unsigned long long ull;
#define x first
#define y second
#define pb push_back
#define mkp make_pair
#define endl "\n"
#define ls u << 1
#define rs u << 1 | 1 
using namespace std;
const int N = (1 << 18) + 10, mod = 998244353;
string s[N];
int n;
int dfs(int u){
	if(u << 1 >= (1 << n)) return 1;
	ll res = 0;
	int l = dfs(ls), r = dfs(rs);
	if(s[ls] < s[rs])
		swap(s[ls], s[rs]);
	if(s[ls] != s[rs])
		res = 1ll * l * r * 2 % mod;
	else
		res = 1ll * l * r % mod;
	s[u] = " " + s[u] + s[ls] + s[rs];
	return res;
}

int main(){
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	cin >> n;
	string str;
	cin >> str;
	for(int i = 1; i < 1 << n; i++){
		s[i] = str[i - 1];
	}
	ll res = dfs(1);
	cout << res << endl;
    return 0;
}

Div3/4

Round #748 div3

D2. Half of Same ( $\color{#F9F}{1900}$ )

题意

D1的加强版，赛中过了，这里就不再单独将D1列出来。D1题意是输入一个数组 $a(-1e6≤a_i≤1e6)，$n$ 个元素 $(4≤n≤40,n为偶数)$ 求出一个最大的整数 $k$，对每个元素减去若干个 $k$ 之后，$a$中所有元素相同。

此题（D2）的题意与D1大致相同，但求一个最大的 $k$，使得数组中至少一半的元素能够相同

思路

两道题答案所包含的元素组成的子数组中，设最小值为 $v$，不难发现，其他元素与$v$的差值（设为$d$ )一定都对$\%k$ 同余。（~~应该这么表示吧?~~）
由上一点可知，$k$ 一定是所有 $d$ 的最大公约数。
D1可以求出最小元素 $v$，再求其他元素相应的 $d$，D2需要观察数据范围，采用暴力枚举所有元素为 $v$，再筛选出其他满足条件的 $d≥0$，存取所有 $d$ 的约数，找出大于等于 $\frac{n}{2}$ 的最大的那个。

自己想法

所有 $d\%k$ 同余想到了，还是没深入思考到 $k$ 一定是所有 $d$ 的最大公约数。

Solution

#include<iostream>
#include<set>
#include<vector>
#include<algorithm>
#include<map>
using namespace std;
int main(){
    int T;
    scanf("%d", &T);
    while(T--){
        int n;
        scanf("%d", &n);
        int a[45];
        for(int i = 1; i <= n; i++)
            scanf("%d", &a[i]);
        int ans = -1;
        for(int i = 1; i <= n; i++){
            int v = a[i];
            vector<int> nums;
            int same = 0;
            for(int j = 1; j <= n; j++){
                int d = a[j] - v;
                if(d == 0) same++;
                if(d > 0) nums.push_back(d);
            }
            if(same >= n / 2){
                ans = INT_MAX;
                continue;
            }
            map<int, int> s;
            for(int j = 0; j < nums.size(); j++){
                int & d = nums[j];
                for(int g = 1; g <= d / g; g++){
                    if(d % g == 0){
                        s[g]++;
                        if(d / g != g)
                        s[d / g]++;
                    }
                }
            }
            for(auto t: s){
                if(t.second >= n / 2 - same){
                    ans = max(ans, t.first);
                }
            }
        }
        if(ans == INT_MAX)
            ans = -1;
        printf("%d\n", ans);
    }
    return 0;
}

Round #780 div3

F2. Promising String ( $\color{#FA8}{2100}$ )

题意

给了长度为 $n$ 的字符串，由 '+' 和 '-' 组成，可以将字符串中两个 '+' 换成 1 个 '-'，询问合法子串个数，合法子串定义，子串内 '+' 数量和 '-' 数量相同。

数据范围
$1\leq n\leq 2*10^5$

思路

F1 $n$ 只有 3000，是一个暴力，F2考虑优化。
我们只关心区间中 '-' 个数与 '+' 个数的差值，自然 '+' 个数比 '-' 小，多模拟一下发现一个简单结论：区间中两数差值 $\mod 3 =0$ 时，区间合法。
因为是一个区间计数问题，我们可以考虑前缀和思想来做，如果两个前缀模 $3$ 同余，那么两个前缀间的区间便合法。
对于这样的问题，由于需要统计 3 个模数的情况，并且不好用单一前缀和数组来统计小于 pre[i] 的所有合法前缀和，考虑用树状数组来处理
所以开 3 个树状数组，tr[i] 表示模数为 $i$ 的前缀和的树状数组，这样统计答案就很方便了。
由于做减法会有负数存在，树状数组只能存正数。所以需要值域整体右移，然后需要一点细节，具体看代码注释。
时间复杂度 $O(nlogn)$

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
#define x first
#define y second
#define pb push_back
#define mkp make_pair
#define endl "\n"
using namespace std;
// 结论：区间内 +号个数 减去 -号个数 % 3 == 0，区间合法，差一定为正数。 
struct BIT {
	int n;
	vector<int> B;
	BIT(){};
	BIT(int _n) : n(_n), B(_n + 1) {}
	void init(int _n){
		n = _n;
		B.resize(_n + 1);
	}
	inline int lowbit(int x) { return x & (-x); }
	void add(int x) {
		for(int i = x; i <= n; i += lowbit(i)) B[i] += 1;
	}
	int ask(int x) {
		int res = 0;
		for(int i = x; i; i -= lowbit(i)) res += B[i];
		return res;
	}
};

int main(){
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int T;
	cin >> T;
	while(T--){
		int n;
		cin >> n;
		string s;
		cin >> s;
		s = " " + s;
		vector<int> pre(n + 1, 0);
		vector<BIT> tr(3, BIT(2 * n + 2));	// 需要加 n + 1, 单单 2 * n 不太够
		for(int i = 1; i <= n; i++)
			pre[i] = pre[i - 1] + (s[i] == '-' ? 1 : -1);
		for(int i = 1; i <= n; i++)
			pre[i] += n + 1;		// 可能为-n，加上n+1才能是正数
		tr[(n + 1) % 3].add(n + 1);	// n+1成了"零"的位置
		ll ans = 0;
		for(int i = 1; i <= n; i++){
			int c = pre[i] % 3;
			ans += tr[c].ask(pre[i]);
			tr[c].add(pre[i]);
		}
		cout << ans << endl;
	}
    return 0;
}

Round #787 div3

F. Vlad and Unfinished Business ( $\color{#AAF}{1800}$ )

题意

给了点数为 $n$ 的树，和 $k$ 个必须到达的点，出发的起点 $x$ 和到达终点 $y$，边权为 $1$ ，询问从起点经过指定的
$k$ 个点，最后到达 $y$ 的最短路径花费， $k$ 个点的访问顺序可以任意。

数据范围
$1\leq k \leq n \leq 2 * 10^5$

思路

贪心地想，对于所有任务点必须到，然后要返回，那么起点到这些点的路径和至少为2倍到达这些点的花费。
问题转化为，经过 $k$ 个点的"最小生成树"，当然这里不需要最小生成树算法，只需要知道我们不需要经过的点数即可，剩余点数为 $x$，路径长度为 $x-1$ 。
那么现在访问了所有点，要更贪心的想，从 $x->y$ 我们是不是只用走一次就行了，先把 $y$ 以外的点搜完，最后来搜 $y$ 的子树即可，那么 $path:x->y$ 只需要经过一次。
所以最后答案为 $2*(必经路径上点数-1) - x->y的深度（距离）$ ，用 dfs 求子树标记的方式来解，详细见代码，时间复杂度 $O(n)$

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef unsigned long long ull;
#define x first
#define y second
#define pb push_back
#define mkp make_pair
#define endl "\n"
using namespace std;
const int N = 2e5 + 10;
int n, k, x, y, ans;
vector<int> edge[N];		// 邻接表存图
int dep[N];
bool st[N];

int dfs(int u, int p){
	int tot = 0;
	for(auto v: edge[u]){
		if(v == p) continue;
		dep[v] = dep[u] + 1;	// 更新深度
		tot += dfs(v, u);
	}
	if(!tot && !st[u]) ans--;	// 不是必经点
	return tot + (st[u] == true);		// 传递标记
}

int main(){
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int T;
	cin >> T;
	while(T--){
		cin >> n >> k;
		cin >> x >> y;
		ans = n;
		vector<int> a(k + 1, 0);
		for(int i = 1; i <= k; i++){
			cin >> a[i];
			st[a[i]] = true;		// 必须经过的点
		}
		st[x] = true, st[y] = true;
		for(int i = 1; i < n; i++){
			int u, v;
			cin >> u >> v;
			edge[u].pb(v);
			edge[v].pb(u);
		}
		dfs(x, -1);
		cout << 2 * (ans - 1) - dep[y] << endl;		// 算答案
		for(int i = 1; i <= n; i++){
			edge[i].clear();
			st[i] = false;
			dep[i] = 0;
		}
	}
    return 0;
}

G. Sorting Pancakes ( $\color{#FB5}{2300}$ )

参考题解: Ximena, 严格鸽

题意
给了一个长度 $n$ 的数组 $a$ ，和保证为 $m$, 每次只能将 $a_i$ 减 1， $a_{i-1}\; or\; a_{i+1}$ 加 1，询问最小的操作次数使 $a$ 非严格递减。

数据范围
$1\leq n,m \leq 250$

思路

毫无疑问，一道dp题，根据数据范围，大概可以容忍 $O(n^3)$ 级别的时空复杂度。
在设计状态前，务必需要一个结论：
- 对于这样的相邻移动元素的操作而言，设操作后的结果为 $b$ 数组，总操作次数等于 $\Sigma_{i=1}^n(|S_b[i] - S_a[i]|)$ ，对应前缀和差的绝对值的和
首先dp的阶段是长度 $i$，由于数组和固定，考虑加入一维当前数组的和 $j$ ，由于要满足递增或者递减，加入一维记录最后一个数 $k$ ，由于需要对比大小，这个数其实是一个最值。
那么状态已经设计出来了： dp[i][j][k] 表示数组前 $i$ 位，和为 $j$ ，最后一位最值为 $k$ 的最小操作次数。
考虑如何转移方便，如果按照题意原本描述来看，转移方程是遍历前一个数 $x,k\leq x$ dp[i][j][k] = min(dp[i][j][k], dp[i - 1][j - k][x] + abs(j - s[i]))，观察发现可以使用最小后缀来优化 $x$ 的遍历，此时预处理最小后缀复杂度为 $O(n^3)$
而考虑反着做，即将数组翻转后，考虑将数组构造成非严格递增。那么 $k$ 代表的是最后一位的最大值。从小到大枚举$k$ 时，需要的是最小前缀，可以很方便的记录, 如下代码所示

for(int i = 1; i <= n; i++){
    for(int j = 0; j <= m; j++){
        int mi = 0x3f3f3f3f;
        for(int k = 0; k <= m - j; k++) {
            mi = min(mi, dp[i - 1][j][k]);      // 转移 k 时，mi 记录了上一位数值为 [0, k] 的最小值，因此是合法的
            f[i][j + k][k] = min(f[i][j + k][k], mi + abs(s[i] - abs(j + k)));
        }
    }
}

时间复杂度：将 $n$ 和 $m$ 同级，$O(n^3)$ ，翻转数组的方法还没有想到如何优化成 $O(n^2logn)$ 。
- 如果尝试采用记录后缀最小来优化，发现对于下标 $i$ 上每个数不能超过 m / i ，否则它一定比前面的某个数大（平均值），加入循环条件中可以做到 $O(n^2logn)$。

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef unsigned long long ull;
#define x first
#define y second
#define pb push_back
#define mkp make_pair
#define endl "\n"
using namespace std;
const int N = 260;
int n, m;
int a[N], s[N];
int dp[N][N][N];		
// 将数组翻转
// dp[i][j][k] 前i个数，和为j，最后一个数最大值为k 满足递增序列最小操作
int main(){
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	cin >> n >> m;
	for(int i = n; i >= 1; i--)
		cin >> a[i];
	for(int i = 1; i <= n; i++)
		s[i] = s[i - 1] + a[i];
	memset(dp, 0x3f, sizeof dp);
	dp[0][0][0] = 0;        // 前0个数，和为0，数最大值为0，操作次数为0
	for(int i = 1; i <= n; i++){
		for(int j = 0; j <= m; j++){
			int mi = 0x3f3f3f3f;
			for(int k = 0; k <= m - j; k++){
				mi = min(dp[i - 1][j][k], mi);
				dp[i][j + k][k] = min(dp[i][j + k][k], mi + abs((j + k) - s[i]));
			}
		}
	}
	int ans = 0x3f3f3f3f;
	for(int i = 0; i <= m; i++)
		ans = min(ans, dp[n][m][i]);
	cout << ans << endl;
    return 0;
}

Round #797 div3

D. Black and White Stripe ( $\color{#CCC}{1000}$ )

固定长度最大子段和, 简单只贴代码了

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef unsigned long long ull;
typedef double db;
#define arr(x) (x).begin(),(x).end()
#define x first
#define y second
#define pb push_back
#define mkp make_pair
#define endl "\n"
using namespace std;

int main(){
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int T;
	cin >> T;
	while(T--){
		int n, k;
		cin >> n >> k;
		vector<int> pre(n + 1, 0);
		string s;
		cin >> s;
		s = " " + s;
		for(int i = 1; i <= n; i++){
			pre[i] = pre[i - 1] + (s[i] == 'B');
		}
		int ans = n;
		for(int i = k; i <= n; i++){
			ans = min(ans, k - (pre[i] - pre[i - k]));
		}
		cout << ans << endl;
	}
    return 0;
}

E. Price Maximization ( $\color{#8DB}{1500}$ )

双指针, 贪心, 排序, 或者 STL

题意

给了 $n$ 个货品, $n$ 是偶数, 每个货品有价值 $a_i$ , 将货品两两配对, 两两配对和总价值为 $w_i$, 给定 $k$, 求 $\Sigma \lfloor \frac{w_i}{k} \rfloor$ 最大值

数据范围
$2\leq n \leq 2*10^5$
$1\leq k \leq 1000$
$0\leq a_i \leq 10^9$

思路

观察数据范围 , $k\leq 1000$.
由于答案为重量之和向下取整, 对 $a_i$ 来说, 无论怎样组合, $a_i / k$ 的贡献是确定的.
这样我们只用关心 $a_i \% k$ 的贡献, 贪心地来想, 对于 $x=a_i\% k$ , 需要找到满足最小余数 $\geq k-x$
可以用两种方式实现
- 一种是显然的双指针 (~~呵呵我写挂了, 很离谱, 有时间来补这个解法~~)
- 还有一种是 jiangly超人的 STL 做法(复杂度稍高但聊胜于无)

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef unsigned long long ull;
typedef double db;
#define arr(x) (x).begin(),(x).end()
#define x first
#define y second
#define pb push_back
#define mkp make_pair
#define endl "\n"
using namespace std;

int main(){
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int T;
	cin >> T;
	while(T--){
		int n, k;
		cin >> n >> k;
		ll ans = 0;
		multiset<int> s;
		for(int i = 0; i < n; i++){
			int x;
			cin >> x;
			ans += x / k;
			s.insert(x % k);
		}
		while(!s.empty()){
			auto x = *s.begin();
			s.erase(s.begin());
			auto it = s.lower_bound(k - x);
			if(it != s.end()){
				s.erase(it);
				ans++;
			}
		}
		cout << ans << endl;
	}
    return 0;
}

F. Shifting String ( $\color{#AAF}{1700}$ )

置换, 环, 字符串最小循环节, LCM

题意

给定一个长度为 $n$ 的字符串 $s$, 和一个排列 $P$ , 每次操作让 $s_i = s_{P_i}$ , 询问至少经过多少次操作能让字符串与初始状态相同

数据范围
$1\leq n \leq 200$
$1\leq p_i \leq n$

思路

草稿纸上画几遍, 发现可能与置换中所形成的各个环的长度有关系, 这个关系是各长度的 $LCM$
答案其实是与每个环经过多少次变换能变成原来的字符串, 由于是字符串关系, 这个多少次变换, 其实就是每个环上对应字符串的最小循环节.
所以答案就是各个环最小循环节长度的 $LCM$
如何求最小循环节? 此题可以暴力枚举循环节长度判断是否合法, 数据规模较大可以使用 KMP 求字符串最小循环节, 得到 $ne$ 数组判断 if(len % (len - ne[len]) == 0)
- 此处给出 KMP 的代码 (依然有些参考 jiangly的实现)

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef unsigned long long ull;
typedef double db;
#define arr(x) (x).begin(),(x).end()
#define x first
#define y second
#define pb push_back
#define mkp make_pair
#define endl "\n"
using namespace std;
const int N = 210;
ll gcd(ll a, ll b){
	return b ? gcd(b, a % b) : a;
}

ll LCM(ll a, ll b){
	return a / gcd(a, b) * b;
}

int main(){
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int T;
	cin >> T;
	while(T--){
		int n;
		string s;
		cin >> n >> s;
		s = " " + s;
		vector<bool> st(n + 1, false);
		vector<int> p(n + 1,0);
		for(int i = 1; i <= n; i++)
			cin >> p[i];
		ll ans = 1;
		for(int i = 1; i <= n; i++){
			if(st[i]) continue;
			string tmp = " ";
			int sz = 0;
			for(int j = i; !st[j]; j = p[j]){
				st[j] = true;
				tmp += s[j];
				sz++;
			}
			vector<int> ne(sz + 1, 0);
			ne[1] = 0;
			for(int i = 2, j = 0; i <= sz; i++){
				while(j && tmp[j + 1] != tmp[i]) j = ne[j];
				if(tmp[i] == tmp[j + 1]) j++;
				ne[i] = j;
			}
			ll len = sz - ne[sz];
			if(sz % len == 0)
				ans = LCM(ans, len);
			else
				ans = LCM(ans, sz);
		}
		cout << ans << endl;
	}
    return 0;
}

G. Count the Trains ( $\color{#F9F}{2000}$ )

STL, 二分, 思维

题意

给了 $n$ 个点, 每个点有值为 $a_i$ , 从左往右形成序列, 对于序列上下标 $i$ 位置, 值为 $min\{a_j\}, (j\leq i)$

有 $m$ 次操作, 输入 $k, d$ , 每次操作对 a[k] -= d , 询问每次操作完之后, 序列中有多少个不同的数 ?

思路

容易挖掘题目性质, 对于一个数 $a_i$ , 如果 $\exist j < i, a_j\leq a_i$ , 那么 $a_i$ 不会对答案产生贡献
由于答案是求不同的数个数 , 我们可以联想到 map, set 这一类 STL 容器来解决, 那么问题是如何实现.
参照第一点, 我们尝试用 map<int,int> 容器来实现, 第一关键字为下标, 第二关键字为对应值
每次输入或操作对 map 中插入 i, a[i], 若前面迭代器元素值小于等于 $a_i$ 则删除现在插入的迭代器, 若没有删除, 检查后面的迭代器是否满足要求(next(it)->second <= it->second)
实现过程中注意代码细节, 防止越界等错误, 时间复杂度为 $O(n+m)log(n+m))$ , 参考 yyds的jiangly

Solution

#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::pair<ll, ll> PLL;
typedef unsigned long long ull;
typedef double db;
#define arr(x) (x).begin(),(x).end()
#define x first
#define y second
#define pb push_back
#define mkp make_pair
#define endl "\n"
using namespace std;
map<int, int> mp;

void add(int i, int x){
	mp[i] = x;
	auto it = mp.find(i);
	if(it != mp.begin() && prev(it)->second <= it->second){
		mp.erase(it);
		return ;
	}
	while(next(it) != mp.end() && next(it)->second >= it->second)
		mp.erase(next(it));
}

int main(){
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int T;
	cin >> T;
	while(T--){
		mp.clear();
		int n, m;
		cin >> n >> m;
		vector<int> a(n + 1, 0);
		for(int i = 1; i <= n; i++){
			cin >> a[i];
			add(i, a[i]);
		}
		while(m--){
			int k, d;
			cin >> k >> d;
			a[k] -= d;
			add(k, a[k]);
			cout << mp.size() << " ";
		}
		cout << endl;
	}
    return 0;
}

野场

3000-3500 #932 9e 35 25
2600-2900 #E54 ed 55 46
2400-2500 #F87 ee 75 6e
2300 #FB5 f5 be 5e
2100-2200 #FA8 f7 cd 8a
1900-2000 #F9F f3 90 ff
1600-1800 #AAF ab a9 ff
1400-1500 #8DB 8d d9 ba
1200-1300 #9F7 95 fc 77
800-1200 #CCC cb cb cb

posted @ 2022-05-06 16:03 Roshin 阅读(465) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Div1

Div1 + Div2 & Global Round

D. Cyclic Rotation ( \(\color{#AAF}{1700}\) )

D. Permutation Graph ( \(\color{#F9F}{1900}\) )

Div2

D. Bear and Floodlight (\(\color{#FA8}{2200}\))

E. Bear in the Field (\(\color{#FB5}{2300}\))

D.Nauuo and Circle ( \(\color{#F9F}{1900}\) ) (结论、计数)

C. Make Them Equal ( \(\color{#9F7}{1200}\) )

D. Reverse Sort Sum ( \(\color{}{1900}\) )

E. Hemose on the Tree ( \(\color{#FA8}{2200}\) )

D. Tokitsukaze and Meeting ( \(\color{#AAF}{1700}\) )

D. Max GEQ Sum (\(\color {#AAF}{1800}\))

C. Zero Path ( \(\color{#AAF}{1700}\) )

C. Helping the Nature ( \(\color{#AAF}{1700}\) )

Education Round

E. Byteland, Berland and Disputed Cities ( \(\color{#FA8}{2200}\) )

B. Minimum Ternary String ( \(\color{#8DB}{1400}\) )

C. Annoying Present ( \(\color{#AAF}{1700}\) )

D. Relatively Prime Graph ( \(\color{#AAF}{1700}\) )

E. Intercity Travelling ( \(\color{#F9F}{2000}\) )

D. Infinite Path ( \(\color{#FA8}{2200}\) )

E. Staircase ( \(\color{#FA8}{2100}\) )

D. Red-Blue Matrix ( \(\color{#F87}{2400}\) )

E. Arena ( \(\color{#FA8}{2100}\) )

E. Messages ( \(\color{#F9F}{2000}\) )

D. MEX Sequences ( \(\color{#F9F}{1900}\) )

D. Exact Change ( \(\color{#F9F}{2000}\) )

E. Replace the Numbers ( \(\color{#F9F}{1900}\) )

E. Math Test ( \(\color{#FA8}{2200}\) )

E. Star MST ( \(\color{#FA8}{2200}\) )

E. Preorder ( \(\color{#FA8}{2100}\) )

Div3/4

D2. Half of Same ( \(\color{#F9F}{1900}\) )

F2. Promising String ( \(\color{#FA8}{2100}\) )

F. Vlad and Unfinished Business ( \(\color{#AAF}{1800}\) )

G. Sorting Pancakes ( \(\color{#FB5}{2300}\) )

D. Black and White Stripe ( \(\color{#CCC}{1000}\) )

E. Price Maximization ( \(\color{#8DB}{1500}\) )

F. Shifting String ( \(\color{#AAF}{1700}\) )

G. Count the Trains ( \(\color{#F9F}{2000}\) )

野场

公告