Codeforces Round #709 (Div. 2, based on Technocup 2021 Final Round)

传送门

Codeforces Round #709 (Div. 2, based on Technocup 2021 Final Round)

A

每个格子至少取一条边进行删除，则删除的格子数 $n\geq a\times b$ ；若能构造出一个解使 $n=a\times b$ ，则可证明答案为 $a\times b$ 。对于每一行，取格子左侧的边进行删除，即可使所有格子都存在一条通向监狱外侧的路径，此时删除的边数为 $a\times b$ 。

#include <bits/stdc++.h>
using namespace std;
int T;
 
int main()
{
    
    
    scanf("%d", &T);
    while (T--)
    {
    
    
        int a, b;
        cin >> a >> b;
        cout << a * b << endl;
    }
    return 0;
}

B

首先预处理 $n = 1$ 的情况。当 $n > 1$ ，即可临项做差分，得到差分数组 $d$ 。由于 $0\leq c<m$ ，且每一项都保证为 $m$ 的模数，则 $d$ 的可能取值至多存在 $2$ 种可能，即 $c$ 与 $c - m$ 。

那么用一个集合维护 $d$ 中的数字，若集合的大小大于 $2$ ，显然无解。若集合大小为 $2$ ，则需要保证集合中的元素为一正一负，此时 $m$ 存在唯一解 $c - (c - m) = m$ ，最后还要判断 $a$ 中的数字是否都满足对 $m$ 取模，即 $a_i<m$ 。若集合大小为 $1$ ，设这个元素为 $d$ ，若 $d\geq 0$ ，则 $m$ 可以取任意大的值；若 $d < 0$ ，此时有 $d = c - m$ ，此时并不存在对 $c$ 的约束条件，则 $c$ 可以取任意大的值， $m$ 依然可以取任意大的值。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int T, N, A[maxn];

int main()
{
    
    
    scanf("%d", &T);
    while (T--)
    {
    
    
        scanf("%d", &N);
        int mx = 0;
        for (int i = 1; i <= N; ++i)
            scanf("%d", A + i), mx = max(mx, A[i]);
        if (N == 1)
        {
    
    
            puts("0");
            continue;
        }
        unordered_set<int> st;
        for (int i = 2; i <= N; ++i)
            st.insert(A[i] - A[i - 1]);
        int res = -1, c = -1;
        if (st.size() == 2)
        {
    
    
            int a = *st.begin(), b = *++st.begin();
            if ((a > 0 && b < 0) || (a < 0 && b > 0))
            {
    
    
                if (a < b)
                    swap(a, b);
                res = a - b, c = a;
            }
        }
        else if (st.size() == 1)
            res = 0;
        if (res > 0 && res <= mx)
            res = -1;
        if (res == 0 || res == -1)
            printf("%d\n", res);
        else
            printf("%d %d\n", res, c);
    }
    return 0;
}

C

$cnt_i$ 代表友人 $i$ 有空的天数。若 $\forall i\in n,cnt_i\leq \lceil m/2\rceil$ ，则可以任意构造一组可行解。反之，一定存在一个 $x$ ，满足 $cnt_x> \lceil m/2\rceil$ ，求出其中一个友人 $x$ ，考虑分配 $x$ 组队 $\lceil m/2\rceil$ 次，此时无论其他人怎么分配，都满足条件。若某一天 $j$ 只有 $x$ 有空，则分配 $x$ 在第 $j$ 天组队，若这样的天数大于 $\lceil m/2\rceil$ ，显然无解；反之，若 $x$ 分配的必要天数 $n u m$ 小于 $\lceil m/2\rceil$ ，则任意分配其余 $\lceil m/2\rceil-num$ 天的任务给 $x$ 。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int T, N, M, cnt[maxn], res[maxn];
vector<int> K[maxn];

int main()
{
    
    
    scanf("%d", &T);
    while (T--)
    {
    
    
        scanf("%d%d", &N, &M);
        memset(res, 0, sizeof(res));
        memset(cnt, 0, sizeof(cnt));
        for (int i = 1; i <= M; ++i)
            K[i].clear();
        for (int i = 1, k, f; i <= M; ++i)
        {
    
    
            scanf("%d", &k);
            for (int j = 1; j <= k; ++j)
                scanf("%d", &f), ++cnt[f], K[i].push_back(f);
        }
        int x = 0, lim = ceil((double)M / 2);
        for (int i = 1; i <= N; ++i)
            if (cnt[i] > lim)
            {
    
    
                x = i;
                break;
            }
        if (x == 0)
        {
    
    
            puts("YES");
            for (int i = 1; i <= M; ++i)
                printf("%d%c", K[i][0], i == M ? '\n' : ' ');
            continue;
        }
        int num = lim;
        for (int i = 1; i <= M; ++i)
            if (K[i].size() == 1 && K[i][0] == x)
                res[i] = x, --num;
        if (num < 0)
        {
    
    
            puts("NO");
            continue;
        }
        for (int i = 1; i <= M; ++i)
            if (!res[i] && num > 0)
                for (auto y : K[i])
                    if (y == x)
                    {
    
    
                        res[i] = x, --num;
                        break;
                    }
        for (int i = 1; i <= M; ++i)
            if (!res[i])
                for (auto y : K[i])
                    if (y != x)
                    {
    
    
                        res[i] = y;
                        break;
                    }
        puts("YES");
        for (int i = 1; i <= M; ++i)
            printf("%d%c", res[i], i == M ? '\n' : ' ');
    }
    return 0;
}

D

暴力模拟 $O(N^2)$ ，考虑优化模拟的过程。首先，需要高效的维护任一元素的下一个满足 $gcd(a_i,a_{nxt[i]})=1$ 的位置 $i$ ；其次，需要高效地维护任一元素的下一未删除元素。

可以使用 $2$ 个并查集维护上述关系。设两类并查集父节点数组分别为 $f_1,f_2$ 。对于第一类并查集，若 $g c d (i, n x t [i] > 1)$ ，则 $f_1[i]=nxt[i]$ ，此时对于每一个节点 $i$ ，其根节点即节点 $i$ 的下一个满足 $gcd(a_j,a_{nxt[j]})=1$ 的位置 $j$ ；根据删除原则，此时删除的 $n x t [j]$ 是并查集某棵树上的叶子节点，删除后不会对其他接节点产生影响。对于第二类关系，当删除节点 $i$ 的元素，则 $f_2[i]=i\mod n+1$ ，此时对于每一个节点 $i$ ，其根节点即节点 $i$ 的下一未删除元素所在的节点。

维护 $2$ 个变量 $n_1,n_2$ ，分别代表 $2$ 个并查集中树的数量。若 $n_1=0$ ，则当前序列都满足相邻元素 $gcd(a_j,a_{nxt[j]})>1$ ，无可删除元素；若 $n_2=0$ ，则当前序列元素个数为 $0$ ，过程无法继续进行。当出现上述情况之一，停止模拟即可。需要注意的是， $f_2$ 节点合并时对应了 $f_1$ 中节点的删除，若当前删除节点为 $f_1$ 中的根节点，则 $n_1$ 减一。总时间复杂度 $O(N(\log A+\log N))$ 。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int T, N, A[maxn], f1[maxn], f2[maxn];
vector<int> res;

int find(int x, int *fa) {
    
     return fa[x] == x ? x : (fa[x] = find(fa[x], fa)); }

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

int main()
{
    
    
    scanf("%d", &T);
    while (T--)
    {
    
    
        res.clear();
        scanf("%d", &N);
        for (int i = 1; i <= N; ++i)
            scanf("%d", A + i);
        int n1 = N, n2 = N;
        for (int i = 1; i <= N; ++i)
            f1[i] = f2[i] = i;
        for (int i = 1; i < N; ++i)
            if (gcd(A[i], A[i + 1]) > 1)
                f1[i] = i + 1, --n1;
        if (gcd(A[1], A[N]) > 1)
            f1[N] = 1, --n1;
        int x = 1, y;
        while (n1 && n2)
        {
    
    
            x = find(x, f1), y = find(x % N + 1, f2);
            res.push_back(y);
            f2[y] = y % N + 1, --n2;
            if (!n2)
                break;
            if (f1[y] == y)
                --n1;
            y = find(y, f2);
            if (x == y)
            {
    
    
                if (A[x] == 1)
                    res.push_back(x);
                break;
            }
            if (gcd(A[x], A[y]) > 1)
                f1[x] = y, --n1;
            x = y;
        }
        printf("%d", (int)res.size());
        for (auto x : res)
            printf(" %d", x);
        putchar('\n');
    }
    return 0;
}

每次操作只关注当前删除节点的下一未删除节点，且操作顺序执行，则可更高效地维护上述关系。

使用链表维护当前节点的下一未删除节点；使用队列维护满足 $g c d (A [i], A [n x t [i]]) = 1$ 的相邻元素。队列中的每一对元素 $(i, j)$ ，只有前一个 $i$ 可能被删除；每次取出队首，判断元素对存在后，将后一元素 $j$ 删除，将队首元素指向 $n x t [j]$ ，并判断 $(i, n x t [i])$ 是否为满足 $g c d (A [i], A [n x t [i]]) = 1$ 的数对，若是，则插入队尾。总时间复杂度 $O(N\log A)$ 。

#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
const int maxn = 100005;
int T, N, A[maxn], nxt[maxn];
bool del[maxn];
vector<int> res;
queue<P> Q;

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

int main()
{
    
    
    scanf("%d", &T);
    while (T--)
    {
    
    
        memset(del, 0, sizeof(del));
        res.clear();
        scanf("%d", &N);
        for (int i = 1; i <= N; ++i)
            scanf("%d", A + i);
        for (int i = 1; i < N; ++i)
            nxt[i] = i + 1;
        nxt[N] = 1;
        for (int i = 1; i < N; ++i)
            if (gcd(A[i], A[i + 1]) == 1)
                Q.push(P(i, i + 1));
        if (gcd(A[N], A[1]) == 1)
            Q.push(P(N, 1));
        while (Q.size())
        {
    
    
            int j = Q.front().first, k = Q.front().second;
            Q.pop();
            if (del[j])
                continue;            
            res.push_back(k);
            nxt[j] = nxt[k], del[k] = 1;
            if (gcd(A[j], A[nxt[j]]) == 1)
                Q.push(P(j, nxt[j]));
        }
        printf("%d", (int)res.size());
        for (auto x : res)
            printf(" %d", x);
        putchar('\n');
    }
    return 0;
}

E 补题

$d p [i]$ 代表建筑 $[1, i]$ 拍成照片可以取得的最大值， $f (i, j)$ 代表将建筑 $[i, j]$ 拍成照片获得的值。枚举最后一张照片的左边界，则有递推 $dp[i]=\max\limits_{0\leq j<i}\{dp[j]+f(j+1,i)\}$ 时间复杂度 $O(N^2)$ ，显然难以胜任。照片值取 $h_i$ 最小的元素的 $b_i$ ，那么设 $j$ 为最大的满足 $j<i,h_j<h_i$ 的元素，此时有 $h_j<\min\limits_{j<k\leq i}h_k,\ h_i<\min\limits_{j<k<i}h_k$ 若将 $i, j$ 置于同一张照片，则求解 $d p [i]$ 等效于求 $d p [j]$ ；反之，取 $\max\limits_{j\leq k<i}dp[k]+b_i$ 。

使用单调递增栈求解 $j$ ，观察到需要维护的值为栈顶节点 $j$ 至当前元素 $i$ 间 $dp[k](j\leq k<i)$ 的最大值，那么在维护单调栈的同时合并栈顶节点的信息即可。总时间复杂度 $O (N)$ 。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 300005;
const ll inf = 0x3f3f3f3f3f3f3f3f;
int N, H[maxn], B[maxn];
int top, st[maxn], id[maxn];
ll dp[maxn];

int main()
{
    
    
    scanf("%d", &N);
    for (int i = 1; i <= N; ++i)
        scanf("%d", H + i);
    for (int i = 1; i <= N; ++i)
        scanf("%d", B + i);
    dp[0] = id[0] = 0, st[++top] = 0;
    for (int i = 1; i <= N; ++i)
    {
    
    
        dp[i] = -inf;
        while (top && H[st[top]] > H[i])
        {
    
    
            if (top - 1 && dp[id[st[top]]] > dp[id[st[top - 1]]])
                id[st[top - 1]] = id[st[top]];
            --top;
        }
        if (top > 1)
            dp[i] = max(dp[i], dp[st[top]]);
        dp[i] = max(dp[i], dp[id[st[top]]] + B[i]);
        st[++top] = i, id[i] = i;
    }
    printf("%lld\n", dp[N]);
    return 0;
}

F 补题

$F l o y d$ 求解任意两点间最短路；枚举每一条边 $(x, y, e s (x, y))$ ，遍历三元组 $(u, v, l)$ 及其反向路径，若满足下述条件，则将对应边计入答案
$dis(u,x)+es(x,y)+dis(y,v)\leq l$ 将 $Q, M$ 的量级看做 $N^2$ ，总时间复杂度 $O(N^4)$ ，显然难以胜任。将不等式变形为 $es(x,y)+dis(y,v)\leq l-dis(u,x)$ 此时左式有 $3$ 个变量，右式有 $3$ 个变量。枚举边 $(x, y)$ ，对于每一个节点 $v$ ，若存在左式小于等于右式最大值的情况，则至少有一个三元组 $(u, v, l)$ 满足条件，则这条边是有用边。

具体而言，枚举左右两边同时出现的变量 $x$ ；枚举 $v, u$ ，求解右式的最大值 $m x [v]$ （其值与 $y$ 无关），然后枚举 $y, v$ ，判断边 $(x, y)$ 是否为有用边。总时间复杂度 $O(N^3)$ 。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 605;
const ll inf = 0x3f3f3f3f3f3f3f3f;
int N, M, Q, es[maxn][maxn], qs[maxn][maxn];
ll ds[maxn][maxn], mx[maxn];

int main()
{
    
    
    scanf("%d%d", &N, &M);
    memset(ds, 0x3f, sizeof(ds));
    for (int i = 1; i <= N; ++i)
        ds[i][i] = 0;
    for (int i = 1, x, y, z; i <= M; ++i)
    {
    
    
        scanf("%d%d%d", &x, &y, &z);
        es[x][y] = es[y][x] = z, ds[x][y] = ds[y][x] = z;
    }
    scanf("%d", &Q);
    for (int i = 1, x, y, z; i <= Q; ++i)
    {
    
    
        scanf("%d%d%d", &x, &y, &z);
        qs[x][y] = qs[y][x] = z;
    }
    for (int k = 1; k <= N; ++k)
        for (int i = 1; i <= N; ++i)
            for (int j = 1; j <= N; ++j)
                ds[i][j] = min(ds[i][j], ds[i][k] + ds[k][j]);
    int res = 0;
    for (int x = 1; x <= N; ++x)
    {
    
    
        for (int v = 1; v <= N; ++v)
        {
    
    
            mx[v] = -inf;
            for (int u = 1; u <= N; ++u)
                if (qs[v][u])
                    mx[v] = max(mx[v], qs[v][u] - ds[u][x]);
        }
        for (int y = 1; y < x; ++y)
            if (es[x][y])
                for (int v = 1; v <= N; ++v)
                    if (es[x][y] + ds[y][v] <= mx[v])
                    {
    
    
                        ++res;
                        break;
                    }
    }
    printf("%d\n", res);
    return 0;
}