CodeForces 843 简要题解

最新推荐文章于 2025-07-02 18:17:34 发布
原创 最新推荐文章于 2025-07-02 18:17:34 发布 · 1.6k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文解析了五道编程挑战题目，包括子序列排序、交互式下界查找、树升级、动态最短路径及最大流问题。每道题目都提供了详细的算法思路与实现代码，覆盖了暴力求解、随机化策略、重心分解、BFS更新及网络流等核心算法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

A. Sorting by Subsequences

暴力。

#include <bits/stdc++.h>
#define xx first
#define yy second
#define mp make_pair
#define pb push_back
#define mset(x, y) memset(x, y, sizeof x)
#define mcpy(x, y) memcpy(x, y, sizeof x)
using namespace std;

typedef long long LL;
typedef pair <int, int> pii;

inline int Read()
{
    int x = 0, f = 1, c = getchar();
    for (; !isdigit(c); c = getchar())
        if (c == '-')
            f = -1;
    for (;  isdigit(c); c = getchar())
        x = x * 10 + c - '0';
    return x * f;
}

const int MAXN = 100005;

int a[MAXN], l[MAXN], n, m;
vector <int> ans[MAXN];
bool v[MAXN];

inline void Dfs(int x)
{
    if (v[x])
        return ;
    v[x] = 1; ans[m].pb(x);
    Dfs(a[x]);
}

int main()
{
#ifdef wxh010910
    freopen("data.in", "r", stdin);
#endif
    n = Read();
    for (int i = 1; i <= n; i ++)
        a[i] = l[i] = Read();
    sort(l + 1, l + n + 1);
    for (int i = 1; i <= n; i ++)
        a[i] = lower_bound(l + 1, l + n + 1, a[i]) - l;
    for (int i = 1; i <= n; i ++)
        if (!v[i])
            m ++, Dfs(i);
    printf("%d\n", m);
    for (int i = 1; i <= m; i ++)
    {
        printf("%d", ans[i].size());
        for (auto x : ans[i])
            printf(" %d", x);
        putchar(10);
    }
}

B. Interactive LowerBound

随机化。
考虑先随机取1000个，然后从最大的小于x的那个开始暴力跳，正确性算算是对的。

include <bits/stdc++.h>
#define xx first
#define yy second
#define mp make_pair
#define pb push_back
#define mset(x, y) memset(x, y, sizeof x)
#define mcpy(x, y) memcpy(x, y, sizeof x)
using namespace std;

typedef long long LL;
typedef pair <int, int> pii;

inline int Read()
{
    int x = 0, f = 1, c = getchar();
    for (; !isdigit(c); c = getchar())
        if (c == '-')
            f = -1;
    for (;  isdigit(c); c = getchar())
        x = x * 10 + c - '0';
    return x * f;
}

const int MAXN = 50005;

int n, s, x, val[MAXN], nxt[MAXN], p[MAXN], cv = -1, cp;

inline int Query(int x)
{
    printf("? %d\n", x);
    fflush(stdout);
    val[x] = Read(), nxt[x] = Read();
}

inline void Print(int x)
{
    printf("! %d\n", x);
    fflush(stdout);
    exit(0);
}

int main()
{
#ifdef wxh010910
    //freopen("data.in", "r", stdin);
#endif
    srand(time(0));
    n = Read(), s = Read(), x = Read();
    for (int i = 1; i <= n; i ++)
        p[i] = i;
    random_shuffle(p + 1, p + n + 1);
    for (int i = 1; i <= n; i ++)
        if (p[i] == s)
            swap(p[i], p[1]);
    for (int i = 1; i <= min(n, 1000); i ++)
    {
        Query(p[i]);
        if (val[p[i]] < x && val[p[i]] > cv)
            cv = val[p[i]], cp = p[i];
    }
    if (!cp)
        Print(val[s]);
    while (true)
    {
        if (!~nxt[cp])
            Print(-1);
        cp = nxt[cp];
        Query(cp);
        if (val[cp] >= x)
            Print(val[cp]);
    }
    return 0;
}

C. Upgrading Tree

那个限制提示我们找重心。
以重心为根构造一下发现可以调整到所有点深度不超过2。
两个重心就分开算就好了。

#include <bits/stdc++.h>
#define xx first
#define yy second
#define mp make_pair
#define pb push_back
#define mset(x, y) memset(x, y, sizeof x)
#define mcpy(x, y) memcpy(x, y, sizeof x)
using namespace std;

typedef long long LL;
typedef pair <int, int> pii;

inline int Read()
{
    int x = 0, f = 1, c = getchar();
    for (; !isdigit(c); c = getchar())
        if (c == '-')
            f = -1;
    for (;  isdigit(c); c = getchar())
        x = x * 10 + c - '0';
    return x * f;
}

const int MAXN = 200005;

int par[MAXN], siz[MAXN], st[MAXN], dep[MAXN], tp, n;
vector <int> adj[MAXN], c[MAXN], r;
vector <pair <int, pii>> ans;

inline void Dfs(int x, int p)
{
    bool f = 1;
    siz[x] = 1;
    for (auto y : adj[x])
        if (y ^ p)
        {
            Dfs(y, x), siz[x] += siz[y];
            if (siz[y] > n >> 1)
                f = 0;
        }
    if (n - siz[x] > n >> 1)
        f = 0;
    if (f)
        r.pb(x);
}

inline void Dfs2(int x, int p)
{
    par[st[tp ++] = x] = p;
    if (dep[x] >= 3)
        c[st[1]].pb(x);
    for (auto y : adj[x])
        if (y ^ p)
            dep[y] = dep[x] + 1, Dfs2(y, x);
    tp --;
}

int main()
{
#ifdef wxh010910
    freopen("data.in", "r", stdin);
#endif
    n = Read();
    for (int i = 1, x, y; i < n; i ++)
        x = Read(), y = Read(), adj[x].pb(y), adj[y].pb(x);
    Dfs(1, 0);
    if (r.size() == 1)
        Dfs2(r[0], 0);
    else
        Dfs2(r[0], r[1]), Dfs2(r[1], r[0]);
    for (int i = 1; i <= n; i ++)
        if (c[i].size())
        {
            int cur = i;
            for (auto x : c[i])
                ans.pb(mp(par[i], mp(cur, x))), ans.pb(mp(x, mp(par[x], i))), cur = x;
            ans.pb(mp(par[i], mp(cur, i)));
        }
    printf("%d\n", ans.size());
    for (auto x : ans)
        printf("%d %d %d\n", x.xx, x.yy.xx, x.yy.yy);
}

D. Dynamic Shortest Path

这是个暴力题…时限有毒…
考虑先跑一遍最短路，由于每次操作只会把边权增加1，所以记dis的delta就可以跑一个BFS之类的东西来更新答案，可以去掉一个log。

#include <bits/stdc++.h>
#define xx first
#define yy second
#define mp make_pair
#define pb push_back
#define mset(x, y) memset(x, y, sizeof x)
#define mcpy(x, y) memcpy(x, y, sizeof x)
using namespace std;

typedef long long LL;
typedef pair <int, int> pii;

inline int Read()
{
    int x = 0, f = 1, c = getchar();
    for (; !isdigit(c); c = getchar())
        if (c == '-')
            f = -1;
    for (;  isdigit(c); c = getchar())
        x = x * 10 + c - '0';
    return x * f;
}

const int MAXN = 100005;

int n, m, Q, mx, hed[MAXN], p[MAXN], v[MAXN], w[MAXN], f[MAXN];
vector <int> d[MAXN];
LL dis[MAXN], INF;
bool vis[MAXN];

inline void Dijkstra()
{
    priority_queue <pair <LL, int>, vector <pair <LL, int>>, greater <pair <LL, int>>> q;
    mset(dis, 0x3f); INF = dis[0];
    dis[1] = 0; q.push(mp(0, 1));
    while (!q.empty())
    {
        int x = q.top().yy; q.pop();
        if (vis[x])
            continue;
        vis[x] = 1;
        for (int i = hed[x]; i; i = v[i])
            if (dis[p[i]] > dis[x] + w[i])
                dis[p[i]] = dis[x] + w[i], q.push(mp(dis[p[i]], p[i]));
    }
}

int main()
{
#ifdef wxh010910
    freopen("data.in", "r", stdin);
#endif
    n = Read(), m = Read(), Q = Read();
    for (int i = 1, x, y; i <= m; i ++)
        x = Read(), y = Read(), w[i] = Read(), p[i] = y, v[i] = hed[x], hed[x] = i;
    Dijkstra();
    while (Q --)
        if (Read() == 1)
        {
            int x = Read();
            if (dis[x] >= INF)
                puts("-1");
            else
                printf("%I64d\n", dis[x]);
        }
        else
        {
            for (int x = Read(); x; x --)
                w[Read()] ++;
            mset(f, 0x3f);
            mx = f[1] = 0; d[0].pb(1);
            for (int i = 0; i <= mx; i ++)
                for (int j = 0; j < d[i].size(); j ++)
                {
                    int x = d[i][j];
                    if (i > f[x])
                        continue;
                    for (int k = hed[x]; k; k = v[k])
                        if (f[p[k]] > f[x] + dis[x] + w[k] - dis[p[k]])
                        {
                            f[p[k]] = f[x] + dis[x] + w[k] - dis[p[k]];
                            if (f[p[k]] <= n)
                                d[f[p[k]]].pb(p[k]), mx = max(mx, f[p[k]]);
                        }
                }
            for (int i = 0; i <= mx; i ++)
                d[i].clear();
            for (int i = 1; i <= n; i ++)
                if (dis[i] < INF)
                    dis[i] += f[i];
        }
    return 0;
}

E. Maximum Flow

你发现那个东西就是要求一个最小割。
对于u到v有流的，要连一条v到u的inf边，否则连u到v的inf边，这样求出来一个割可以保证这样不会再能增广。
然后随便跑个上下界网络流就行了。

#include <bits/stdc++.h>
#define xx first
#define yy second
#define mp make_pair
#define pb push_back
#define mset(x, y) memset(x, y, sizeof x)
#define mcpy(x, y) memcpy(x, y, sizeof x)
using namespace std;

typedef long long LL;
typedef pair <int, int> pii;

inline int Read()
{
    int x = 0, f = 1, c = getchar();
    for (; !isdigit(c); c = getchar())
        if (c == '-')
            f = -1;
    for (;  isdigit(c); c = getchar())
        x = x * 10 + c - '0';
    return x * f;
}

const int MAXN = 105;
const int MAXM = 10005;
const int INF = 0x3f3f3f3f;

namespace Flow
{
    struct Edge
    {
        int p, v, w;
    } e[MAXM];

    int e_cnt, S, T, V, ql, qr, q[MAXN], hed[MAXN], dis[MAXN], cur[MAXN];

    inline void Init(int n)
    {
        V = n;
        for (int i = 0; i < V; i ++)
            hed[i] = 0;
        e_cnt = 1;
    }

    inline void Addedge(int x, int y, int w)
    {
        e[++ e_cnt] = {y, hed[x], w}; hed[x] = e_cnt;
        e[++ e_cnt] = {x, hed[y], 0}; hed[y] = e_cnt;
    }

    inline bool Bfs()
    {
        for (int i = 0; i < V; i ++)
            dis[i] = 0;
        dis[q[ql = 0] = S] = qr = 1;
        while (ql ^ qr)
        {
            int x = q[ql ++];
            for (int i = hed[x]; i; i = e[i].v)
                if (e[i].w && !dis[e[i].p])
                    dis[q[qr ++] = e[i].p] = dis[x] + 1;
        }
        return dis[T];
    }

    inline int Dfs(int x, int f)
    {
        if (x == T)
            return f;
        int ret = 0, t = 0;
        for (int &i = cur[x]; i; i = e[i].v)
            if (e[i].w && dis[e[i].p] == dis[x] + 1)
            {
                t = Dfs(e[i].p, min(f, e[i].w));
                f -= t; ret += t; e[i].w -= t; e[i ^ 1].w += t;
                if (!f)
                    return ret;
            }
        return dis[x] = -1, ret;
    }

    inline int Dinic()
    {
        int ret = 0;
        while (Bfs())
        {
            for (int i = 0; i < V; i ++)
                cur[i] = hed[i];
            ret += Dfs(S, INF);
        }
        return ret;
    }
}

int n, m, s, t, d[MAXN], u[MAXM], v[MAXM], f[MAXM], g[MAXM];

int main()
{
#ifdef wxh010910
    freopen("data.in", "r", stdin);
#endif
    n = Read(), m = Read(), s = Read(), t = Read();
    Flow::Init(n + 1); Flow::S = s; Flow::T = t;
    for (int i = 1; i <= m; i ++)
        u[i] = Read(), v[i] = Read(), g[i] = Read(), Flow::Addedge(u[i], v[i], g[i] ? 1 : INF), d[u[i]] ++, d[v[i]] --;
    for (int i = 1; i <= m; i ++)
        if (g[i])
            Flow::Addedge(v[i], u[i], INF);
    printf("%d\n", Flow::Dinic());
    for (int i = 1; i <= m; i ++)
        if (g[i])
            if (Flow::dis[u[i]] && !Flow::dis[v[i]])
                f[i] = 1;
    Flow::Init(n + 2); Flow::S = 0, Flow::T = n + 1;
    for (int i = 1; i <= m; i ++)
        if (g[i])
            Flow::Addedge(u[i], v[i], INF);
    Flow::Addedge(t, s, INF);
    for (int i = 1; i <= n; i ++)
        if (d[i] > 0)
            Flow::Addedge(i, n + 1, d[i]);
        else
            Flow::Addedge(0, i, -d[i]);
    Flow::Dinic();
    for (int i = 1, cnt = 0; i <= m; i ++)
        if (!g[i])
            puts("0 1");
        else
            cnt ++, printf("%d %d\n", Flow::e[cnt << 1 | 1].w + 1, Flow::e[cnt << 1 | 1].w + (!f[i]) + 1);
    return 0;
}
wxh010910
关注
Codeforces 题解 （不断更新，一起上分）
DeathYmz的博客
08-02 9589
目录 Educational Codeforces Round 45 (Rated for Div. 2) Educational Codeforces Round 45 (Rated for Div. 2) 题目：A. Commentary Boxes题解 题目：B Micro-World 题解 题目：C Bracket Sequences Concatenation Problem 题解 题目：D Graph And Its Complement 题解 题目：E Po...
Codeforces 1120 简要题解
苟为蒟蒻又何妨
03-12 1065
文章目录A题B题C题D题E题F题 传送门 A题 传送门 题意简述：给你一个mmm个数的数列，现在规定把一个数列的1,2,...,k1,2,...,k1,2,...,k分成第一组，把k+1,k+2,...,2kk+1,k+2,...,2kk+1,k+2,...,2k分成第二组,…,这样把前n∗kn*kn∗k个数分成nnn组，现在给你sss个数，你可以删去至多m−n∗km-n*km−n∗k个数使得新数...
Codeforces 1103 简要题解
苟为蒟蒻又何妨
01-23 990
传送门 又一场原地爆炸的比赛。 AAA题简单思维 题意：给一个4∗44*44∗4的格子图和一个01串，你要根据01串放1∗21*21∗2的木块，如果是0就竖放一个，是1就横放一个，一行或者一列满了可以直接消掉。 现在让你每次输出放下木块的坐标，并保证所有操作中没有木块相交。 思路： 可以直接按照自己的思路模拟然后我这个sb想了好久用什么策略 下来之后突然想到一个更简单的做法，我们保证如果竖放先放...
Codeforces Round 1034 (Div. 3) G 题解
最新发布
AKDreamer_HeXY的博客
07-02 936
题目要求维护一个数组，支持修改元素和查询操作。查询时需要判断是否存在通过多次加k取模m的操作使数组单调不减。解法基于裴蜀定理，预处理每个元素对所有m的因数取模的结果，并统计需要调整的次数。修改时更新预处理数据，查询时检查处理后数组是否满足条件。时间复杂度为O(√m + n√m + q√m)。
Codeforces 1110 简要题解
weixin_30851867的博客
02-08 224
文章目录A题B题C题D题E题F题G题 传送门 众所周知ldxoildxoildxoi这种菜鸡选手是不会写HHH题的，因此该篇博客只有AAA题至GGG题的题解，实在抱歉。 A题 传送门 题意简述：给出b,kb,kb,k和a1,a2,...,aka_1,a_2,...,a_ka1​,a2​,...,ak​问bk−1a1+bk−2a2+...+akb^{k...
codeforces 题解
忘梦心的博客
01-10 1396
1285A Mezo Playing Zoma 查看题解 字符串 1285B Just Eat It! 查看题解 最大连续子序列 1285C Fadi and LCM 查看题解 数论 1285D Dr. Evil Underscores 查看题解 dfs+位运算 ...
Codeforces 845 简要题解
苟为蒟蒻又何妨
03-22 681
文章目录A题B题C题D题E题F题G题 传送门 A题 传送门 题意：2n2n2n个人下棋，分为两个阵营，每个阵营nnn个人，每个人有一个积分，积分高的能赢积分低的，问如果你可以随意选人，然后每场比赛随机安排对局，最后AAA阵的棋手能否全胜。 思路： 看积分nnn大的和n+1n+1n+1大的积分是否相同 代码： #include<bits/stdc++.h> #define ri re...
Codeforces1200 简要题解
苟为蒟蒻又何妨
08-13 616
文章目录ABCDEF 传送门 总结一下： CCC题读入进来的时候没开longlonglong longlonglong导致fstfstfst. FFF题最后5min5min5min才发现一个细节读错了最后凉凉. 还是挺遗憾的 A 暴力模拟即可。 #include<bits/stdc++.h> #define ri register int #define fi first #defin...
Codeforces 1197 简要题解
苟为蒟蒻又何妨
07-24 907
文章目录A题B题C题D题EF题 比赛传送门 A题 传送门 排个序然后取a[n−1]−1a[n-1]-1a[n−1]−1与n−2n-2n−2的最小值。 代码： #include<bits/stdc++.h> #define ri register int #define fi first #define se second using namespace std; inline int ...
Codeforces gym 102822 简要题解
mayaohua
11-22 905
博主诈尸啦！来更点cf题解。 A. A Colorful Grid 分类讨论鬼题。 先考虑一下最后的网格图的连通性。我们考虑某一个连通块，如果存在某个连通块外的点与连通块内至少两个点相邻，或者至少两个连通块外的点与连通块内某个点相邻，那么连通块都能继续扩大。这样容易发现，最终可能的连通块一定要么是横着切成若干块，要么是竖着切成若干块，当然也可以是整个网格图完全连通。接下来我们的算法是枚举每一类情况，看看是否能构造出解，如果均不行就无解。 如果整个网格图完全连通。不妨设n≤mn\leq mn≤m，若n≤2n\
Codeforces题目泛做解题报告许昊然.pdf
05-21
来自2012，2013年国际信息奥林匹克金牌得主许昊然
codeforces题解
MekakuCityActors的博客
05-29 916
Codeforces Round #562 (Div. 2)
codeforces题解（800）
qq_56853912的博客
07-09 1188
目录A. Optimal PathA. The Third Three Number ProblemA. XOR Mixuptime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputYou are given a table aa of size n×mn×m. We will consider the table rows numbered from top t
【cf】Codeforces 题解等汇总
青少年趣味编程
05-24 2719
【cf】Codeforces Round #774 (Div. 2) 前4题 【cf】Codeforces Round #774 (Div. 2) 前4题_legend_yst的博客-优快云博客 【算法刷题】排序：CodeForces 984A，CodeForces 1132B，CodeForces 1015C 【算法刷题】排序：CodeForces 984A，CodeForces 1132B，CodeForces 1015C_一只小榨菜的博客-优快云博客 题目：codeforces 1
codeforces查看题解
m0_62024160的博客
08-07 2092
文章目录1. 步骤一：右键单击箭头指向位置，根据提示打开链接2. 步骤二：左键单击箭头指向位置3. 结果：红线上方是参考代码，下方是测试样例4. 补充：① 右边这个方框可以筛选想要查看代码的状态(Accepted、Wrong answer等)以及提交的语言② 下方这一栏可以按运行时间(或者内存损耗等)对代码进行排序 1. 步骤一：右键单击箭头指向位置，根据提示打开链接 2. 步骤二：左键单击箭头指向位置 3. 结果：红线上方是参考代码，下方是测试样例 4. 补充： ① 右边这个方框可以筛选想要查看代码
codeforces Hello 2024个人题解（A~C）
Lazy_ChessPlayer的博客
01-07 1402
1秒256兆标准输入标准输出ab爱丽丝和鲍勃很无聊，于是他们决定用自己的钱包玩一个游戏。爱丽丝的钱包里有a枚硬币，而鲍勃的钱包里有b枚硬币。双方轮流玩，由爱丽丝先走棋。10无法在自己的回合中做出有效举动的玩家输。如果爱丽丝和鲍勃都以最佳方式下棋，则决定谁将赢得游戏。
Codeforces题解整合【按照场次】
mengxiang000000
12-19 2598
本贴只给出传送门，用于整合。 本帖只会给出整场全部题的题解。 没有做出来全部题的场次的题解不进行记录。 也算用于给自己一种补题的督促动力吧。 Codeforces Round #383 (Div. 2)【A.B.C.D.E】： http://blog.youkuaiyun.com/mengxiang000000/article/details/53503168 http://blo
Codeforces 中文题解（持续更新）
TGX的博客
01-30 2776
Codeforces近期比赛中文题解
codeforces round 97
03-26
接下来，用户需要问题和解决方案，所以需要简要描述每个题目的问题，并给出解决思路或示例代码。例如，对于构造排列的题目，可能需要排列的特定性质，如相邻元素满足某种条件。对于时间安排问题，可能需要计算每个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值