Codeforces Round #677 (Div. 3)A-G题解

关注

原创最新推荐文章于 2026-04-08 09:49:43 发布 1.7k 阅读 AI 写同款· GEO 优化 ›

Codeforces 题解（不断更新，一起上分）目录 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 Round #677 (Div. 3)A-G题解
比赛链接:https://codeforces.ml/contest/1433/

A题
水，施行

题意为给定一个1到9999的每一位上数字相同的整数x，现在按照一定规则报数，问报到x的时候，总共报了多少位的数字。
报数规则为从1,11,111,1111到2,22,222,2222…到9,99,999,9999。

注意到我们需要关注的只是x是由哪个数字构成的，以及x有几位。
假设x是由若干个y构成的，对于任意的数字比如1，喊完1，11，111，1111总共要报10位数字。因此报到y之前总共要报10(y-1)位，之后再看当前的x要报几次，1，2，3，4依次加上去就是了。

#include<bits/stdc++.h>
#define ll long long
#define llINF 9223372036854775807
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;

int32_t main()
{
    IOS;
    int t;
    cin>>t;
    while(t--)
    {
        int x;
        cin>>x;
        int ans=10*(x%10-1);
        int cas=0;
        while(x)
        {
            cas++;
            ans+=cas;
            x/=10;
        }
        printf("%d\n",ans);
    }
}

B题
贪心，思维

题意为给定一个01数列a[]，每次操作我们可以选择一个连续的1区间，把他们整体左移或者整体右移一个位置，询问最少要多少次操作可以使得所有的1都在一个连续的区间。

注意到对于所有1的初始位置中，最左侧和最右侧的下标位置构成的区间，对于这区间内的0，我们每次操作最多并且必然可以（操作最左侧或者最右侧的连续1区间即可）使得它们减少1。执行此贪心过程的话我们的最少操作次数就是这段区间内0的个数了。
统计即可。

#include<bits/stdc++.h>
#define ll long long
#define llINF 9223372036854775807
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;

bool flag[60];

int32_t main()
{
    int t;
    cin>>t;
    while(t--)
    {
        int n;
        cin>>n;
        int pre=-1,ans=0;//pre标记上一段连续1区间的右侧位置
        for(int i=1;i<=n;i++)
        {
            cin>>flag[i];
            if(flag[i]&&!flag[i-1]&&pre!=-1)//记录连续1区间之间的0的个数，pre=-1的时候代表是最左侧的0区间不需要计算进去
            {//flag[i]=1，flag[i-1]为0，正好是连续0区间到连续1区间的分界处
                ans+=i-pre;//两个位置下标相减，即为这一段连续0区间的长度
                pre=-1;
            }
            if(!flag[i]&&flag[i-1]) pre=i;
        }
        cout<<ans<<endl;
    }
}

C题
贪心，构造

题意为有n条鱼，排成一排，每条鱼有一个初始的力量值。我们需要选定一条鱼，他每次可以吃掉自己左边或者右边的一条鱼，并且每吃掉一条鱼后，自己的力量值+1。询问是否存在这样一条鱼，可以把所有的其他鱼吃掉，输出位置下标。

首先想一下不存在这样的鱼的情况。那就是所有鱼的初始力量都相同时，没有鱼可以吃掉其他鱼。
那么当不是所有鱼的初始力量值都相同的时候，我们必定可以找到一个初始的最大力量值，并且拥有这个最大力量值的所有鱼当中，必定存在一条鱼的周围有比他力量值小的鱼（否则就是所有鱼初始力量值都相等的情况了）。我们选定这样一条初始为最大力量值，周围有比他力量值小的鱼，吃掉旁边这条鱼后力量值+1，便成为了所有鱼中严格拥有最大力量值的唯一一条鱼，任意吃掉其他鱼即可。

因此我们只需要判断是否有这样一条初始为最大力量值，周围有比他力量值小的鱼即可。

#include<bits/stdc++.h>
#define ll long long
#define llINF 9223372036854775807
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;
const ll maxn=3e5+7;

int num[maxn];

int32_t main()
{
    IOS;
    int t;
    cin>>t;
    while(t--)
    {
        int n;
        cin>>n;
        int M=0;//所有初始值中的最大值
        for(int i=1;i<=n;i++)
        {
            cin>>num[i];
            M=max(M,num[i]);
        }
        int tar=-1;//寻找答案位置
        for(int i=1;i<=n;i++)
        {
            if(num[i]==M)//值要与初始最大值相同
            {
                if(i>1&&num[i-1]!=M) tar=i;//与左侧或者右侧的值不同的位置，均满足要求，输出任意一个
                if(i+1<=n&&num[i+1]!=M) tar=i;
            }
        }
        cout<<tar<<endl;
    }
}

D题
构造

题意为给定n个点，你需要构造n-1条边，把这n个点连接成一个连通图。但是每个点都有一个标记值，标记值相同的点不能用某条边直接连接，只能间接连通。询问是否有满足要求的构造方法。

思考过程如上题，首先无法构造的情况，所有点的标记值都相同，我们无法构造任何边，故此情况下不存在满足要求的构造方法。
那么当并不是所有点的标记值都相同的情况下，必然存在两个下标的点x和y，他们的标记值是不同的。那么我们把所有与x点标记值不同的点（包括y）都与x连接起来，那么就只剩下标记值与x相同的点没有连接进来了，我们将这些点与y点连接起来即可。便能构造出满足要求的连通图。

按照以上思路构造即可。

#include<bits/stdc++.h>
#define ll long long
#define llINF 9223372036854775807
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;

int32_t main()
{
    IOS;
    int t;
    cin>>t;
    while(t--)
    {
        int n;
        cin>>n;
        vector<ll>num(n);
        for(auto &x:num) cin>>x;
        int tar=-1;
        for(int i=1;i<n;i++)
            if(num[i]!=num[i-1])//寻找是否有标记值不同的两个点
            {
                tar=i;
                break;
            }
        if(tar==-1) cout<<"NO"<<endl;//所有点标记值相同，无法构造任何边
        else
        {
            cout<<"YES"<<endl;
            for(int i=0;i<n;i++)
            {
                if(i!=tar-1)
                {
                    if(num[i]!=num[tar-1]) cout<<tar<<' '<<i+1<<endl;//如果标记值与tar-1下标点的值不同，则连接到tar-1点上
                    else cout<<tar+1<<' '<<i+1<<endl;//如果与tar-1点的标记值相同，则连接到tar点上，tar点与tar-1点标记值不同固必定符合要求
                }
            }
        }
    }
}

E题
组合数学

题意为给定n个人，标记为1-n，n为偶数。现在需要你将这n个人分为人数相同的两组，每组都给定一个排列顺序，询问总共有多少种不同的分法。其中排列[1,2,3,4]和[2,3,4,1]和[3,4,1,2]和[4,1,2,3]这样循环相同的排列被认为是相同的排列方式。

首先很容易想到的，分为两组必定要计算组合数C(n/2,n)，然后A，B和B，A两种方式重复，再除以2。接着需要考虑的就是两个分组各自有多少种不同的排列了。不考虑循环相同的情况下，n/2长度的排列数为(n/2)!，而考虑循环相同，每n/2种排列构成相同的一种排列方式，因此总方案数应该是(n/2-1)!。两个分组的排列情况相乘，因此最后的总排列数应该为C(n/2,n)/2 $×\times$ (n/2-1)! $×\times$ (n/2-1)!。

#include<bits/stdc++.h>
#define ll long long
#define llINF 9223372036854775807
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;

int32_t main()
{
    IOS;
    int n;
    cin>>n;
    ll ans=1;
    for(int i=1;i<=n/2;i++) ans=ans*(n-i+1)/i;//计算C(n/2,n)，划分成两组
    for(int i=2;i<n/2;i++) ans*=i*i;//乘上两边n!，并且除掉两个n，化简后便是该循环。此处为两组当中排列方式不同的情况，除掉n是因为循环相同的排列也属于排列方式相同
    cout<<ans/2<<endl;//A,B和B,A的分法重复，除以2
}

F题
dp

题意为给定一个n $×\times$ m的矩阵，每行最多取m/2个数字，要找到一个最大的总和值，满足能被k整除。

注意到数据范围都很小，都只有70。
对于每行来说，我们可以按照取了几个数字，对k取模等于多少，分为70/2 $×\times$ 70种状态。使用dp去计算每行取不超过m/2个数的情况下，对k取模为j时，能得到的最大总和值，再将它用同样的dp方式，计算到最终答案上即可。
具体实现和转移方程见代码。

#include<bits/stdc++.h>
#define ll long long
#define llINF 9223372036854775807
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;

int n,m,k;

int dp[50][100],ans[2][100];//dp[i][j]讨论的是某一行，代表选择了i个数的情况下，得到的sum对k取模等于j的情况下，sum的最大值
//ans数组则用滚动数组来记录最终答案，ans[i][j]，代表当前已经dp计算得的所有行累加情况下，得到的sum对k取模等于j的情况下，sum的最大值

int32_t main()
{
    IOS
    bool flag=0;
    cin>>n>>m>>k;
    int lim=m/2;//每行最多取lim个数
    for(int i=0;i<n;i++)
    {
        memset(dp,0,sizeof(dp));
        for(int j=0;j<m;j++)
        {
            int x;cin>>x;
            for(int q=lim-1;q>=0;q--)//注意这里循环是从大到小
            {
                for(int p=0;p<k;p++)
                {
                    int temp=dp[q][p]+x;
                    if(temp>dp[q+1][temp%k]) dp[q+1][temp%k]=temp;
                }
            }
        }
        for(int q=0;q<k;q++)
        {
            for(int p=0;p<k;p++)
            {
                int temp=ans[flag][p]+dp[lim][q];
                if(ans[!flag][temp%k]<temp) ans[!flag][temp%k]=temp;
            }
        }
        //for(int i=0;i<k;i++) cout<<ans[!flag][i]<<endl;
        flag=!flag;//滚动数组翻滚
    }
    cout<<ans[flag][0]<<endl;
}

G题
最短路，暴力，复杂度分析

题意为给定一个n个点，m条双向边的连通图，给定k条路径的起终点。询问在将最多一条边的权值修改为0的情况下，这k条路径的消耗总和的最小值。

注意到数据范围都很小，最大1000。因此可以采取暴力一些的做法。
如果我们暴力枚举删除每条边，每次删除后暴力去跑k次Dijskra的话，总复杂度mk(n+m)logn，1e9带常数的级别，必定会tle。
这代表我们的方法过分暴力了，注意到上述表述中有两个暴力过程，我们尝试思考是否可以把其中的某一部分暴力过程优化。
对于我们把i点到j点的路径置为0，对于从q点到p点的最短路径来说，存在两种大的情况。
1.i到j点路径置为0后，q点到p点的最短路径选择未受影响
2.i到j点路径置为0后，q点到p点的最短路径选择受到影响，并且i点到j点的路径必定在新的最短路径上。

对于第二种情况，可以是q->i->j->p也可以是q->j->i->p，这两种路径长度分别为q到i的最小距离加上j到p的最小距离，和q到j的最小距离加上i到p的最小距离。这两种方案与原本不把路径置零的情况下q到p的最小距离取最小值，即为把i到j点路径置为0后，q到p的最短距离了。

有了上述结论后，我们注意到，上面需要的三个距离，我们只需对k次询问的所有起终点，都跑一次Dijskra即可。总复杂度2k(n+m)logn。
离线计算k次询问的所有起终点，到其他所有点的最短距离，之后跑一次km复杂度的计算即可。

#include<bits/stdc++.h>
#define ll long long
#define llINF 9223372036854775807
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;
const int maxn=1e3+7;

int n,m,k,tot;

struct Edge
{
    int to,next,dis;
}edge[maxn*2];

int head[maxn];

void init()
{
    for(int i=1;i<=n;i++) head[i]=-1;
    tot=0;
}

void add(int u,int v,int w)
{
    edge[tot].dis=w;
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot++;
}

ll dis[maxn][maxn];//dis[i][j]记录i点到j点的最短距离

struct Node
{
    int pos;ll val;
    Node(int pos,ll val):pos(pos),val(val){}
    friend bool operator < (Node a,Node b)
    {
        return a.val>b.val;
    }
};

void Dijskra(int st)
{
    for(int i=1;i<=n;i++) dis[st][i]=llINF;
    dis[st][st]=0;
    priority_queue<Node>Q;Q.push(Node(st,0));
    while(Q.size())
    {
        Node now=Q.top();
        Q.pop();
        if(now.val>dis[st][now.pos]) continue;
        for(int i=head[now.pos];i!=-1;i=edge[i].next)
        {
            int to=edge[i].to;
            if(dis[st][to]>edge[i].dis+now.val)
            {
                dis[st][to]=edge[i].dis+now.val;
                Q.push(Node(to,dis[st][to]));
            }
        }
    }
}

int u[maxn],v[maxn],w[maxn],st[maxn],ed[maxn];

int32_t main()
{
    IOS
    cin>>n>>m>>k;
    init();
    for(int i=0;i<m;i++)
    {
        cin>>u[i]>>v[i]>>w[i];
        add(u[i],v[i],w[i]);add(v[i],u[i],w[i]);
    }
    for(int i=0;i<k;i++)
    {
        cin>>st[i]>>ed[i];
        Dijskra(st[i]);Dijskra(ed[i]);//预处理出所有询问的起终点，到其他所有点的距离
        //单次Dijskra复杂度为(n+m)logn,要跑2k次，总复杂度2k(n+m)logn
    }
    ll ans=llINF;
    for(int i=0;i<m;i++)//此处O(1)计算，总复杂度mk
    {
        ll temp=0;
        for(int j=0;j<k;j++) temp+=min(dis[st[j]][ed[j]],min(dis[st[j]][u[i]]+dis[ed[j]][v[i]],dis[st[j]][v[i]]+dis[ed[j]][u[i]]));
        ans=min(ans,temp);
    }
    cout<<ans<<endl;
}