Codeforces Round #407 (Div. 2) 解题报告

最新推荐文章于 2025-08-01 11:12:48 发布

OI李想

最新推荐文章于 2025-08-01 11:12:48 发布

阅读量417

点赞数

CC 4.0 BY-SA版权

分类专栏： Codeforces 文章标签： codeforces

本文链接：https://blog.youkuaiyun.com/lixiang99410/article/details/68484048

Codeforces 专栏收录该内容

16 篇文章

订阅专栏

本文解析了五道经典编程题目，包括贪心算法、DP、图论和搜索等问题，提供了详细的代码实现及思路分析。

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

Problem A-Anastasia and pebbles
简单贪心

//Author: Lixiang
#include<stdio.h>
#include<algorithm>
using namespace std;
const int maxn=100001;
int floordiv(double a,double b){
    return (int)a/b;
}
struct Peb{
    int a[maxn],N,K;
    void init(){
        scanf("%d%d",&N,&K);
        for(int i=1;i<=N;i++)
            scanf("%d",&a[i]);
        sort(a+1,a+N+1);
    }
    void work(){
        int cnt=N,ans=0;
        for(int i=N;a[i]>K;i--){
            if(a[i]>2*K){
                int k=floordiv(a[i],2*K);
                ans+=k;
                a[i]-=2*K*k;
                if(a[i]>K){
                    ans++;
                    a[i]=0;
                }
                if(a[i]==0)cnt--;
            }
            else{
                a[i]-=K;
                ans++;
                cnt--;
            }
        }
        printf("%d\n",floordiv(cnt,2)+cnt%2+ans);
    }
}sol;
int main(){
    sol.init();
    sol.work();
    return 0;
}

Problem B-Masha and geometric depression
判断几个特殊情况即可
注意如果|b1|>L直接输出0

//Author: Lixiang
#include<stdio.h>
#include<map>
using namespace std;
map <long long,int> hash;
template <class T>
T abs(T a){
    return a>0?a:-a;
}
struct ALG{
    long long B1,Q,L,tmp;
    int M;
    void init(){
        scanf("%I64d%I64d%I64d%d",&B1,&Q,&L,&M);
        for(int i=1;i<=M;i++){
            scanf("%I64d",&tmp);
            hash[tmp]=1;
        }
    }
    void work(){
        if(abs(B1)>L){
            puts("0");
            return ;
        }
        if(B1==0){
            if(hash[0]==1)printf("%d\n",0);
            else printf("inf\n");
            return ;
        }
        if(Q==0){
            if(hash[0]==1){
                if(hash[B1]==1||abs(B1)>L)printf("%d\n",0);
                else printf("%d\n",1);
            }
            else printf("inf\n");
            return ;
        }
        if(Q==1){
            if(hash[B1]==1||abs(B1)>L)printf("%d\n",0);
            else printf("inf\n");
            return ;
        }
        if(Q==-1){
            if(abs(B1)>L||(hash[B1]==1&&hash[-B1]==1))printf("%d\n",0);
            else printf("inf\n");
            return ;
        }
        int cnt=0;
        while(abs(B1)<=L){
            if(hash[B1]==1)B1*=Q;
            else{
                B1*=Q;
                cnt++;
            }
        }
        printf("%d\n",cnt);
    }
}sol;
int main(){
    sol.init();
    sol.work();
    return 0;
}

Problem C-Functions again
dp,对于(a[i]-a[i+1])*(-1)^k求两次最大子段和

//Author: Lixiang
#include<stdio.h>
const int maxn=100001;
template <class T>
T abs(T a){
    return a>0?a:-a;
}
struct C{
    int a[maxn],b[maxn],c[maxn];
    int N;
    void init(){
        scanf("%d",&N);
        for(int i=1;i<=N;i++)
            scanf("%d",&a[i]);
        for(int i=2,flag=1;i<=N;i++,flag*=(-1))
            b[i]=abs(a[i-1]-a[i])*flag;
        for(int i=2,flag=-1;i<=N;i++,flag*=(-1))
            c[i]=abs(a[i-1]-a[i])*flag;
    }
    void work(){
        long long sum=0,ans=0;
        for(int i=2;i<=N;i++){
            if(sum==0&&i%2==1)continue;
            sum+=b[i];
            if(sum<0)sum=0;
            if(sum>ans)ans=sum;
        }
        sum=0;
        for(int i=2;i<=N;i++){
            if(sum==0&&i%2==0)continue;
            sum+=c[i];
            if(sum<0)sum=0;
            if(sum>ans)ans=sum;
        }
        printf("%I64d\n",ans);
    }
}sol;
int main(){
    sol.init();
    sol.work();
    return 0;
}

Problem D-Weird journey

给你一个双向路径图（可能不连通且存在自环,同样的边不会出现两次），n个节点，m条边，要求划出一条路径，使得其中（m-2）条边每条边走两次，另外两条边每条边走一次，问有多少种不同的路径。

这题乍一看，像不像欧拉路，很像啊，欧拉路是划出一条路径经过所有的边一次且仅一次，而这个是选出(m-2)条边来走两次。那我们不妨将这(m-2)条边再建一条，比如，

u<–>v，那我们再建一条u<–>v。那么如果修改后的图能跑出一条欧拉路的话，那么就符合题意了，所以我们就枚举这些边。由于（m-2）可能比较大，那么我们就枚举这个2，即不增建的边。

我们判定欧拉路的依据是奇数度数节点只有两个或者没有。那么我们枚举每一条边，将此边不增，其他的每条边都扩增一条，那么此时除了这条边连接的两个端点（u!=v）

以外，其他的所有节点的度数都是偶数，这两个节点的度数都是奇数。等会，我们还差一条边，，，现在已经有两个节点度数是奇数了，那么我们要拆的下一条边就必须是与这两个节点相关的（可以自己想想为什么）那么这条边的贡献就是这两个节点所连得边的和-1了。还有就是如果你拆了某个自环的边，也是可以的。还有种情况就是你一开始选的是一个自环的边，那么你下一条要拆的随便那条边都行。

//Author: Lixiang
#include<stdio.h>
#include<vector>
#include<string.h>
using namespace std;
const int maxn=1000001;
struct Edge{
    int u,v;
    void init(int x,int y){
        u=x;v=y;
    }
};
struct Weird_journey{
    vector <int> ADJL[maxn];
    Edge edge[maxn];
    int cnt[maxn],in[maxn],N,M,loop;
    bool vis[maxn];
    void dfs(int id){
        vector <int>::iterator it;
        vis[id]=1;
        for(it=ADJL[id].begin();it!=ADJL[id].end();it++)
            if(!vis[*it])
                dfs(*it);
    }
    void init(){
        memset(cnt,-1,sizeof(cnt));
        scanf("%d%d",&N,&M);
        for(int i=1,u,v;i<=M;i++){
            scanf("%d%d",&u,&v);
            edge[i].init(u,v);
            if(u!=v){
                ADJL[u].push_back(v);
                ADJL[v].push_back(u);
                cnt[u]++;cnt[v]++;
            }
            else loop++;
            in[u]++;in[v]++;
        }
        for(int i=1;i<=N;i++)
            if(in[i]){
                dfs(i);
                break;
            }
    }
    void work(){
        long long ans=0;
        for(int i=1;i<=N;i++)
            if(!vis[i]&&in[i]){
                puts("0");
                return ;
            }
        for(int i=1;i<=M;i++){
            if(edge[i].u!=edge[i].v)ans+=cnt[edge[i].u]+cnt[edge[i].v]+loop;
            else ans+=(M-1);
        }
        printf("%I64d\n",ans/2);
    }
}sol;
int main(){
    sol.init();
    sol.work();
    return 0;
}

Problem E-The Great Mixing
原方程为

\sum i = 1 K a i x i = \sum i = 1 K x i N

$\sum_{i=1}^{K}a_{i}x_{i}=\sum_{i=1}^{K}x_{i}N$
可化作

\sum i = 1 K (a i - N) x i = 0

$\sum_{i=1}^{K}(a_{i}-N)x_{i}=0$
无限背包模型，用BFS求解找到满足条件且

∑Ki=1xi $\sum_{i=1}^{K}x_{i}$ 最小的解。

//Author: Lixiang
#include<stdio.h>
#include<queue>
#include<string.h>
#include<algorithm>
using namespace std;
const int maxk=1000001;
const int maxn=1001;
struct E{
    queue <int> Q;
    int a[maxk],A[maxk],f[maxn],N,K;
    void init(){
        int k;
        memset(f,-1,sizeof(f));
        scanf("%d%d",&N,&k);
        for(int i=1;i<=k;i++){
            scanf("%d",&A[i]),A[i]-=N;
        }
        sort(A+1,A+k+1);
        for(int i=1;i<=k;i++){
            Q.push(A[i]);
            a[++K]=A[i];
            f[a[K]]=1;
            while(A[i+1]==A[i])i++;
        }
    }
    void bfs(){
        int h;
        while(!Q.empty()){
            h=Q.front();
            Q.pop();
            for(int i=1;i<=K;i++){
                if(h+a[i]>=0&&h+a[i]<=1000&&f[h+a[i]]==-1){
                    f[h+a[i]]=f[h]+1;
                    Q.push(h+a[i]);
                }
            }
        }
    }
    void work(){
        bfs();
        printf("%d\n",f[0]);
    }
}sol;
int main(){
    sol.init();
    sol.work();
    return 0;
}