AtCoder Peterzavodsk Contest 001 题解

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

本文解析了几道算法竞赛题目，包括求解特定数学问题、数组操作、图论算法、树结构处理等，提供了详细的代码实现及思路说明。

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

A. Two integers

求是 xx 的倍数且不是 yy 的倍数的一个数 zz ，要求 zz 不超过 10181018 。

#include<bits/stdc++.h>

#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-funroll-loops")
#pragma GCC target("avx,sse4")

#define mms(a,n) memset(a,0,sizeof((a)[0])*(n))
#define mmp(a,b,n) memcpy(a,b,sizeof((b)[0])*(n))
#define lowbit(x) ((x)&-(x))
#define pb push_back
#define fi first
#define se second
#define debug(...) fprintf(stderr,__VA_ARGS__)
#define fo(i,l,r) for(register int i=l,_lim_=r;i<=_lim_;i++)
#define fd(i,r,l) for(register int i=r,_lim_=l;i>=_lim_;i--)
#define fos(i,l,r,d) for(register int i=l,_lim_=r;i<=r;i+=d)
#define fol(i,l,r) for(register ll i=l,_lim_=r;i<=_lim_;i++)
#define fdl(i,r,l) for(register ll i=r,_lim_=l;i>=_lim_;i--)
#define fosl(i,l,r,d) for(register ll i=l,_lim_=r;i<=r;i+=d)
#define Clear(a) memset(a,0,sizeof(a))
#define Copy(a,b) memcpy(a,b,sizeof(b))
#define ALL(v) v.begin(),v.end()
#define SZ(v) ((int)v.size())

using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef long double ldb;
typedef double db;
typedef pair<int,int> pi;

int x,y;

int main(){
    cin>>x>>y;
    cout<<(x%y?x:-1);
    return 0;
}

B. Two Arrays

有两个数组 aa 和 bb ，每次可以给 aa 中一个元素 +2+2 ，并同时给 bb 中一个元素 +1+1 ，问能否使得 aa 和 bb 相同。范围 105105 。

增加的次数是确定的，于是先加完 22 再补 11 ，只要 aa 中对应位置元素不小于 bb 中即可。

#include<bits/stdc++.h>

#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-funroll-loops")
#pragma GCC target("avx,sse4")

#define mms(a,n) memset(a,0,sizeof((a)[0])*(n))
#define mmp(a,b,n) memcpy(a,b,sizeof((b)[0])*(n))
#define lowbit(x) ((x)&-(x))
#define pb push_back
#define fi first
#define se second
#define debug(...) fprintf(stderr,__VA_ARGS__)
#define fo(i,l,r) for(register int i=l,_lim_=r;i<=_lim_;i++)
#define fd(i,r,l) for(register int i=r,_lim_=l;i>=_lim_;i--)
#define fos(i,l,r,d) for(register int i=l,_lim_=r;i<=r;i+=d)
#define fol(i,l,r) for(register ll i=l,_lim_=r;i<=_lim_;i++)
#define fdl(i,r,l) for(register ll i=r,_lim_=l;i>=_lim_;i--)
#define fosl(i,l,r,d) for(register ll i=l,_lim_=r;i<=r;i+=d)
#define Clear(a) memset(a,0,sizeof(a))
#define Copy(a,b) memcpy(a,b,sizeof(b))
#define ALL(v) v.begin(),v.end()
#define SZ(v) ((int)v.size())

using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef long double ldb;
typedef double db;
typedef pair<int,int> pi;

const int N=10005;
int n,a[N],b[N];
ll x,y;

int main(){
    scanf("%d",&n);
    fo(i,1,n)scanf("%d",a+i);
    fo(i,1,n)scanf("%d",b+i);
    fo(i,1,n)x+=max(b[i]-a[i]+1,0)>>1,y+=b[i]-a[i];
    if(y<x)puts("No");else puts("Yes");
    return 0;
}

C. Vacant Seat

有 n≤105n≤105 个位置排成一个环，其中 nn 是奇数，在其中有数字 0,1,20,1,2 ，其中 00 和 11 都不能连续出现，不超过 2020 次询问一个位置的值，找出一个 22 的位置。

讨论区间长度和左右填的数字可知其中是否一定出现 22 ，于是每次二分即可。

#include<bits/stdc++.h>

#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-funroll-loops")
#pragma GCC target("avx,sse4")

#define mms(a,n) memset(a,0,sizeof((a)[0])*(n))
#define mmp(a,b,n) memcpy(a,b,sizeof((b)[0])*(n))
#define lowbit(x) ((x)&-(x))
#define pb push_back
#define fi first
#define se second
#define debug(...) fprintf(stderr,__VA_ARGS__)
#define fo(i,l,r) for(register int i=l,_lim_=r;i<=_lim_;i++)
#define fd(i,r,l) for(register int i=r,_lim_=l;i>=_lim_;i--)
#define fos(i,l,r,d) for(register int i=l,_lim_=r;i<=r;i+=d)
#define fol(i,l,r) for(register ll i=l,_lim_=r;i<=_lim_;i++)
#define fdl(i,r,l) for(register ll i=r,_lim_=l;i>=_lim_;i--)
#define fosl(i,l,r,d) for(register ll i=l,_lim_=r;i<=r;i+=d)
#define Clear(a) memset(a,0,sizeof(a))
#define Copy(a,b) memcpy(a,b,sizeof(b))
#define ALL(v) v.begin(),v.end()
#define SZ(v) ((int)v.size())

using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef long double ldb;
typedef double db;
typedef pair<int,int> pi;

int n;

int Query(int u){
    static char ch[10];
    printf("%d\n",u);fflush(stdout);
    scanf("%s",ch);
    if(*ch=='V')exit(0);
    return *ch=='M'?1:0;
}
void solve(int l,int r,int s){
    int mi=(l+r+1)>>1,st=Query(mi),dif=st^s;
    if(dif!=((mi-l)&1))
        solve(l,mi-1,s);
    else
        solve(mi,r,st);
}

int main(){
    scanf("%d",&n);
    solve(0,n-1,Query(0));
    return 0;
}

D. Forest

给一个森林，每个点有权值 aiai ，增加若干条边使得森林联通，且每个点最多与一条新增加的边相连。求有新增加的边相连的点的权值和的最小值。范围 105105 。

显然每个联通块至少有一个点被计算，且所有联通块中共有 2m−22m−2 个点被计算。于是删掉一个联通块中最小的元素算进答案中，剩下来按顺序加起来即可。时间复杂度可以做到 O(n)O(n) 。

#include<bits/stdc++.h>

#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-funroll-loops")
#pragma GCC target("avx,sse4")

#define mms(a,n) memset(a,0,sizeof((a)[0])*(n))
#define mmp(a,b,n) memcpy(a,b,sizeof((b)[0])*(n))
#define lowbit(x) ((x)&-(x))
#define pb push_back
#define fi first
#define se second
#define debug(...) fprintf(stderr,__VA_ARGS__)
#define fo(i,l,r) for(register int i=l,_lim_=r;i<=_lim_;i++)
#define fd(i,r,l) for(register int i=r,_lim_=l;i>=_lim_;i--)
#define fos(i,l,r,d) for(register int i=l,_lim_=r;i<=r;i+=d)
#define fol(i,l,r) for(register ll i=l,_lim_=r;i<=_lim_;i++)
#define fdl(i,r,l) for(register ll i=r,_lim_=l;i>=_lim_;i--)
#define fosl(i,l,r,d) for(register ll i=l,_lim_=r;i<=r;i+=d)
#define Clear(a) memset(a,0,sizeof(a))
#define Copy(a,b) memcpy(a,b,sizeof(b))
#define ALL(v) v.begin(),v.end()
#define SZ(v) ((int)v.size())

using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef long double ldb;
typedef double db;
typedef pair<int,int> pi;

const int N=100005;
int n,m,a[N],fa[N],blk;
vector<int>e[N],E;
ll ans;

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

int main(){
    scanf("%d%d",&n,&m);
    fo(i,1,n)scanf("%d",&a[i]),fa[i]=i,blk++;
    for(int i=1,u,v;i<=m;i++){
        scanf("%d%d",&u,&v);u++;v++;
        if(find(u)!=find(v))fa[find(u)]=find(v),blk--;
    }
    fo(i,1,n)e[find(i)].pb(a[i]);
    if(blk==1)puts("0"),exit(0);
    int cur=blk-2;
    fo(i,1,n)if(e[i].size()){
        sort(ALL(e[i]));
        ans+=e[i][0];
        fo(j,1,int(e[i].size())-1)E.pb(e[i][j]);
    }
    sort(ALL(E));
    if(cur>E.size())puts("Impossible"),exit(0);
    fo(i,0,cur-1)ans+=E[i];
    cout<<ans<<endl;
    return 0;
}

E. Antennas on Tree

有一棵 n≤105n≤105 个点的树，无边权。你要在上面选 kk 个点，一个点的坐标由它到每个点的树上距离定义为一个 kk 维的坐标。求最小的 kk 使得坐标两两不同。

首先我们考虑在什么情况下坐标会相同。容易发现坐标相同意味着对于一个点来说，有两个不同的子树满足其中没有选择的点，这样这两个子树的根节点的坐标就相同了。
假设我们已经选出了 kk 个点，那么我们将所有在这 kk 个点两两路径上的所有点拿出来，这是这棵树的一个子联通块，也是一棵树。同时这棵树恰好有 kk 个叶子，也就是我们选出的点。容易发现，需要满足的条件就是未被选出的点是若干条链，且任意一个被选的点至多和一个未被选出的点相连。
也就是说我们现在要选择一个子联通块满足上面的条件，同时叶子尽量少。
于是我们对于每个原树中的叶子给一个标号，就是沿着叶子向上碰到的最近的度数 >2>2 的节点。我们删除未被选的节点的过程实际上就是把叶子到他的标号的这条链缩起来，然后这个标号就不能再缩了。
于是我们只要算有多少种标号就行了，时间复杂度 O(n)O(n) 。
特判一下一条链的情况即可。

#include<bits/stdc++.h>

#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-funroll-loops")
#pragma GCC target("avx,sse4")

#define mms(a,n) memset(a,0,sizeof((a)[0])*(n))
#define mmp(a,b,n) memcpy(a,b,sizeof((b)[0])*(n))
#define lowbit(x) ((x)&-(x))
#define pb push_back
#define fi first
#define se second
#define debug(...) fprintf(stderr,__VA_ARGS__)
#define fo(i,l,r) for(register int i=l,_lim_=r;i<=_lim_;i++)
#define fd(i,r,l) for(register int i=r,_lim_=l;i>=_lim_;i--)
#define fos(i,l,r,d) for(register int i=l,_lim_=r;i<=r;i+=d)
#define fol(i,l,r) for(register ll i=l,_lim_=r;i<=_lim_;i++)
#define fdl(i,r,l) for(register ll i=r,_lim_=l;i>=_lim_;i--)
#define fosl(i,l,r,d) for(register ll i=l,_lim_=r;i<=r;i+=d)
#define Clear(a) memset(a,0,sizeof(a))
#define Copy(a,b) memcpy(a,b,sizeof(b))
#define ALL(v) v.begin(),v.end()
#define SZ(v) ((int)v.size())

using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef long double ldb;
typedef double db;
typedef pair<int,int> pi;

const int N=100005;
int n,m;bool vi[N];
vector<int>e[N];
int dfs(int u,int fa){
    if(e[u].size()>2)return u;
    for(int v:e[u])if(v!=fa)return dfs(v,u);
    return u;
}

int main(){
    scanf("%d",&n);
    for(int i=1,u,v;i<n;i++)scanf("%d%d",&u,&v),u++,v++,e[u].pb(v),e[v].pb(u);
    fo(i,1,n)if(e[i].size()==1)vi[dfs(i,0)]=true,m++;
    fo(i,1,n)if(vi[i])m--;if(!m)m++;
    printf("%d\n",m);
    return 0;
}

F. XOR Tree

给一棵 n≤105n≤105 个节点的树，每条边上有权值 vi≤15vi≤15 ，每次可以选择一条路径将路径上所有的边权值异或某个数 ww 。求最少多少次将所有边权变成 00 。

令 ViVi 表示所有与 ii 相连的边权的异或和，于是每次就是将两个值异或上一个数 ww ，最后使得所有数为 00 。首先相同的肯定两两配对，令 dp[S]dp[S] 表示集合 SS 中的元素还有 11 个时的答案，每次显然会将一个元素异或为 00 ，于是直接 dpdp 即可。时间复杂度 O(n+224)O(n+224) 。

#include<bits/stdc++.h>

#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-funroll-loops")
#pragma GCC target("avx,sse4")

#define mms(a,n) memset(a,0,sizeof((a)[0])*(n))
#define mmp(a,b,n) memcpy(a,b,sizeof((b)[0])*(n))
#define lowbit(x) ((x)&-(x))
#define pb push_back
#define fi first
#define se second
#define debug(...) fprintf(stderr,__VA_ARGS__)
#define fo(i,l,r) for(register int i=l,_lim_=r;i<=_lim_;i++)
#define fd(i,r,l) for(register int i=r,_lim_=l;i>=_lim_;i--)
#define fos(i,l,r,d) for(register int i=l,_lim_=r;i<=r;i+=d)
#define fol(i,l,r) for(register ll i=l,_lim_=r;i<=_lim_;i++)
#define fdl(i,r,l) for(register ll i=r,_lim_=l;i>=_lim_;i--)
#define fosl(i,l,r,d) for(register ll i=l,_lim_=r;i<=r;i+=d)
#define Clear(a) memset(a,0,sizeof(a))
#define Copy(a,b) memcpy(a,b,sizeof(b))
#define ALL(v) v.begin(),v.end()
#define SZ(v) ((int)v.size())

using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef long double ldb;
typedef double db;
typedef pair<int,ll> pi;

namespace io{
    const int L=(1<<21)+1;
    char ibuf[L],*iS,*iT,obuf[L],*oS=obuf,*oT=obuf+L-1,c,st[55];int f,tp;
    #ifdef whzzt
        #define gc() getchar()
    #else
        #define gc() (iS==iT?(iT=(iS=ibuf)+fread(ibuf,1,L,stdin),(iS==iT?EOF:*iS++)):*iS++)
    #endif
    inline void flush(){fwrite(obuf,1,oS-obuf,stdout);oS=obuf;}
    inline void putc(char x){*oS++=x;if(oS==oT)flush();}
    template<class I>
    inline void gi(I&x){
        for(f=1,c=gc();c<'0'||c>'9';c=gc())if(c=='-')f=-1;
        for(x=0;c<='9'&&c>='0';c=gc())x=x*10+(c&15);x*=f;
    }
    template<class I>
    inline void print(I x){
        if(!x)putc('0');if(x<0)putc('-'),x=-x;
        while(x)st[++tp]=x%10+'0',x/=10;
        while(tp)putc(st[tp--]);
    }
    inline void gs(char*s,int&l){
        for(c=gc();c<'a'||c>'z';c=gc());
        for(l=0;c<='z'&&c>='a';c=gc())s[l++]=c;
    }
    inline char O(){
        for(c=gc();c!='C'&&c!='Q'&&c!='R';c=gc());
        return c;
    }
    inline void ps(const char*s){
        fo(i,0,strlen(s)-1)putc(s[i]);
    }
};
using io::putc;
using io::gi;
using io::gs;
using io::print;

const int N=100005;
int n,x[N],cnt[1<<4],u,v,w,ans,dp[1<<16],st;
bool vi[1<<16];

int dfs(int S){
    if(!S)return 0;if(vi[S])return dp[S];
    vi[S]=true;
    int ret=233;
    fo(i,1,15)if(S>>i&1)fo(j,1,15)if(i!=j&&(S>>j&1)){
        int T=S^(1<<i)^(1<<j)^(1<<(i^j));
        if(__builtin_popcount(T)<__builtin_popcount(S))ret=min(ret,dfs(T)+1+(~T>>(i^j)&1));
    }
    return dp[S]=ret;
}

int main(){
    gi(n);
    fo(i,2,n)gi(u),gi(v),gi(w),x[u+1]^=w,x[v+1]^=w;
    fo(i,1,n)if(x[i])cnt[x[i]]++;
    fo(i,0,15)ans+=cnt[i]>>1,st|=(cnt[i]&1)<<i;
    ans+=dfs(st);
    printf("%d\n",ans);
    return 0;
}

后面的题除了 HH 有一点思路之外全凉了，特别是 II ，真的神仙。

G. Colorful Doors

有 2n2n 个位置，将 1...n1...n 中的每个数放在两个位置。一开始在 11 位置，要走到 2n2n 位置，那么将每个数看做传送门，碰到放在的某个位置就传送到对应的另一个位置，从 11 开始走到 2n2n 结束。现在给定经过的所有的间隔，求一种放数字的方案。n≤105n≤105 。

首先将 2n2n 到 11 也看做一个间隔，那么每个间隔有唯一前驱和后继，形成了若干环，然后我们把这个间隔的访问情况也当做一个 11 扔进序列里面就行了。

考虑如果输入的全是 11 的时候怎么做，稍微画一下可以发现 nn 是奇数的时候无解，偶数的时候只要 1,2,1,2,3,4,3,4...1,2,1,2,3,4,3,4... 这样构造一下就行了，这一部分的问题很好解决。

同时我们会发现如果一开始有偶数个 11 ，补完之后变成了奇数个 11，也很好发现这样是无解的，因为有偶数个限制（单向边可以当成双向边用并查集并起来），每个点被偶数个限制作用，所以有用的限制也是偶数个，奇数个就无解了。

把间隔看成边，在中间建立点，那么一端为 00 的肯定是作为连接两段 11 出现的，只考虑两端都是 11 的这些点。

如果这些点的个数为奇数就是之前说的无解情况。如果是 44 的倍数直接按顺序连起来之后就变成了之前全是 11 且 nn 为偶数的情况。否则的话，假如只有一段的点只有两端，其他的点肯定连起来，就变成了访问的全是 11 且 nn 是奇数的情况了，无解。

如果有两段的话，我们考虑将这两段并起来。只要把第一段的第一个左右两边都是 11 的点和第二段中的第一个这样的点都赋值上同一个值，就可以将两条链交错拼起来，两端都是 11 的点的个数减少了 22 个，就可以使用之前的做法了。

这一部分题解里有图，可以稍微看一下。

如果还是不太懂可以看代码或者题解，虽然感觉题解也不太清楚。

神仙。

#include<stdio.h>
#include<vector>
#include<stdlib.h>

#define SZ(v) ((int)v.size())
#define pb push_back
using namespace std;
typedef vector<int> VI;

const int N=200005;
VI li[N],id;
char s[N];
int n,m,L,ec,sum,mark[N];

void markit(){
    for(int i=0;i<<2<id.size();i++){
        for(int j:{0,1})for(int k:{0,1})mark[id[i<<2|j<<1|k]]=ec+k+1;
        ec+=2;
    }
}
void output(){
    puts("Yes");
    for(int i=0;i<L;i++){
        if(!mark[i])mark[i]=ec<0?-ec:++ec,ec=-ec;
        printf("%d ",mark[i]);
    }
    exit(0);
}

int main(){
    scanf("%d",&n);scanf("%s",s+1);s[0]='1';L=n<<1;
    for(int i=0,j;i<L;i++)if(s[i]=='0'&&s[(i+1)%L]=='1'){
        for(li[m].pb(i),j=(i+1)%L;s[j]=='1';j=(j+1)%L)li[m].pb(j);
        m++;
    }
    if(!m){
        if(~n&1){
            for(int i=0;i<L;i++)id.pb(i);
            markit();output();
        }else puts("No"),exit(0);
    }
    for(int i=0;i<m;i++)sum+=SZ(li[i])-2;
    if(sum&1)puts("No"),exit(0);
    if(sum&2){
        for(int i=0;i<m;i++)if(SZ(li[i])>2)li[m-1].swap(li[i]);
        for(int i=0;i<m-1;i++)if(SZ(li[i])>2){
            VI&a=li[i],&b=li[m-1];
            int la=SZ(a)-1,lb=SZ(b)-1,ea=a[la],eb=b[lb];
            mark[a[la-1]]=mark[b[lb-1]]=++ec;
            a.pop_back();b.pop_back();a.pop_back();b.pop_back();a.push_back(eb);b.push_back(ea);
            sum-=2;
            break;
        }
        if(sum&2)puts("No"),exit(0);
    }
    for(int i=0;i<m;i++){
        mark[li[i][0]]=ec+1+i;
        mark[li[i][SZ(li[i])-1]]=ec+1+(i+1)%m;
        for(int j=1;j<SZ(li[i])-1;j++)id.pb(li[i][j]);
    }
    ec+=m;markit();output();
    return 0;
}

H. Generalized Insertion Sort

给定一棵 n≤2000n≤2000 个节点的树，每个点有点权，所有点的点权是一个排列，每次操作选择一个点 vv ，并将从根到 vv 的路径上的权值循环移位一次，其中根节点的点权变成节点 vv 的点权，节点 vv 的点权变成节点 vv 父亲的点权······。
要求在 2500025000 次操作内将权值 ii 移动到节点 ii 上。

首先将树轻重链剖分，每次将最下层的重链拿走，这样由于轻重链剖分的性质，最多会拿 O(logn)O(log⁡n) 次，实际上树链剖分最多有 1010 层。
考虑链剖之后如何将最下层的所有点上的权值修改正确，不妨称这些最下层重链上的点为红点，其他点为蓝点。
首先如果是一条链的话很好处理，第 ii 次操作维护链的最后 ii 个的偏序正确即可。这样我们只要 nn 次操作。考虑如何拓展到树上。
注意到我们每次只有均摊的 25002500 次操作，和 nn 是同阶的，所以我们在每次要尽量使得每个权值只出现在根节点一次，实际上我们之前的链的做法也就是保证了这一点。
令BB 为已访问的蓝点集合，RR 为未到过根的权值集合。
定义势能函数 δ=|R|+∑i∈B[R∩subtree{i}≠∅]δ=|R|+∑i∈B[R∩subtree{i}≠∅] 。下面我们考虑 δδ 函数的变化，显然终止状态的 δ≥0δ≥0。
假设有一个红点到了根，这个红点一定未访问，而扔下去后前面的值一定减小 11 ，后面的值有 |red||red| 次会增加，对于整个过程来说是 nn 次。
假设有一个蓝点到了根，那么我们肯定是将这个蓝点扔到某个蓝点堆的上方。那么我们扔到哪一个呢？我们扔到一个蓝点堆的堆顶上方，使得整个子树的权值都不在 RR 中，这样的方案显然存在，而这也不会对势能函数的后半部分产生影响。而一个已经被访问过的蓝点重新到根意味着后面的值要 −1−1，于是最多有 |red||red| 个蓝点被扔了两次。所以这部分总共会有 nn 个蓝点被多扔。
所以总的时间复杂度为 O(n2logn)O(n2log⁡n)，操作的复杂度为 O(nlogn)O(nlog⁡n) 。

#include<bits/stdc++.h>

#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-funroll-loops")
#pragma GCC target("avx,sse4")

#define mms(a,n) memset(a,0,sizeof((a)[0])*(n))
#define mmp(a,b,n) memcpy(a,b,sizeof((b)[0])*(n))
#define lowbit(x) ((x)&-(x))
#define pb push_back
#define fi first
#define se second
#define debug(...) fprintf(stderr,__VA_ARGS__)
#define fo(i,l,r) for(register int i=l,_lim_=r;i<=_lim_;i++)
#define fd(i,r,l) for(register int i=r,_lim_=l;i>=_lim_;i--)
#define fos(i,l,r,d) for(register int i=l,_lim_=r;i<=r;i+=d)
#define fol(i,l,r) for(register ll i=l,_lim_=r;i<=_lim_;i++)
#define fdl(i,r,l) for(register ll i=r,_lim_=l;i>=_lim_;i--)
#define fosl(i,l,r,d) for(register ll i=l,_lim_=r;i<=r;i+=d)
#define Clear(a) memset(a,0,sizeof(a))
#define Copy(a,b) memcpy(a,b,sizeof(b))
#define ALL(v) v.begin(),v.end()
#define SZ(v) ((int)v.size())

using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef long double ldb;
typedef double db;
typedef pair<int,ll> pi;

namespace io{
    const int L=(1<<21)+1;
    char ibuf[L],*iS,*iT,obuf[L],*oS=obuf,*oT=obuf+L-1,c,st[55];int f,tp;
    #ifdef whzzt
        #define gc() getchar()
    #else
        #define gc() (iS==iT?(iT=(iS=ibuf)+fread(ibuf,1,L,stdin),(iS==iT?EOF:*iS++)):*iS++)
    #endif
    inline void flush(){fwrite(obuf,1,oS-obuf,stdout);oS=obuf;}
    inline void putc(char x){*oS++=x;if(oS==oT)flush();}
    template<class I>
    inline void gi(I&x){
        for(f=1,c=gc();c<'0'||c>'9';c=gc())if(c=='-')f=-1;
        for(x=0;c<='9'&&c>='0';c=gc())x=x*10+(c&15);x*=f;
    }
    template<class I>
    inline void print(I x){
        if(!x)putc('0');if(x<0)putc('-'),x=-x;
        while(x)st[++tp]=x%10+'0',x/=10;
        while(tp)putc(st[tp--]);
    }
    inline void gs(char*s,int&l){
        for(c=gc();c<'a'||c>'z';c=gc());
        for(l=0;c<='z'&&c>='a';c=gc())s[l++]=c;
    }
    inline char O(){
        for(c=gc();c!='C'&&c!='Q'&&c!='R';c=gc());
        return c;
    }
    inline void ps(const char*s){
        fo(i,0,strlen(s)-1)putc(s[i]);
    }
};
using io::putc;
using io::gi;
using io::gs;
using io::print;

const int N=2005;
int n,p[N],w[N],sz[N],son[N],bel[N],bot[N],m,pos[N];
bool del[N],red[N],vi[N];
vector<int>e[N],O,li[N];

void dfs(int u){
    sz[u]=1;
    for(int v:e[u]){
        dfs(v),sz[u]+=sz[v];
        if(sz[v]>sz[son[u]])son[u]=v;
    }
}
void dfs(int u,int b){
    bel[u]=b;li[b].pb(u);pos[u]=SZ(li[b]);
    if(u==b)red[u]=true;if(e[u].size()>1)red[b]=false;
    if(son[u])dfs(son[u],b);else bot[b]=u;
    for(int v:e[u])if(v!=son[u])dfs(v,v);
    if(red[u])for(int v:li[u])red[v]=true,m++;
}
void flip(int u){
    O.pb(u);for(int v=p[u];v;v=p[v])swap(w[v],w[u]);
}
int find(int u){
    bool o=true;
    for(int v:e[u]){
        int p=find(v);
        if(p>0)return p;
        o&=p==-1; 
    }
    if(o)return vi[w[u]]?-1:u;
    return 0;
}
void move(){
    int u=w[1];if(!vi[u])vi[u]=true;m-=red[u];
    if(red[u])for(int v=bot[bel[u]];v;v=p[v])if(!red[w[v]]||!vi[w[v]]||pos[w[v]]<=pos[u])return flip(v);
    flip(find(1));
}
bool fix(){
    fo(i,2,n)if(!del[i])e[p[i]].pb(i);
    if(!e[1].size())return false;
    dfs(1);dfs(1,1);
    while(m)move();
    fo(i,1,n)e[i].clear(),li[i].clear(),del[i]|=red[i],red[i]=vi[i]=bot[i]=pos[i]=bel[i]=son[i]=sz[i]=0;m=0;
    return true;
}

int main(){
    gi(n);
    fo(i,2,n)gi(p[i]),p[i]++;
    fo(i,1,n)gi(w[i]),w[i]++;
    while(fix());
    print(O.size());putc('\n');
    for(int v:O)print(v-1),putc('\n');
    io::flush();
    return 0;
}

I. Simple APSP Problem

在 n×m (n,m≤106)n×m (n,m≤106) 的网格上有 K≤30K≤30 个障碍，求所有点之间两两的最短路之和。

神仙题。考虑两行如果都是空格，那么我们可以计算出中间的边经过的次数然后合并。同时如果两列都是空格，也可以类似处理，于是这些没有障碍的行列之间的边权都变成了 00 。我们只要将 00 联通块缩起来，这些点出去的最短路是相同的，问题就只要直接进行一次 BFSBFS 即可。时间复杂度 O(K4)O(K4) 。

#include<bits/stdc++.h>

#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-funroll-loops")
#pragma GCC target("avx,sse4")

#define mms(a,n) memset(a,0,sizeof((a)[0])*(n))
#define mmp(a,b,n) memcpy(a,b,sizeof((b)[0])*(n))
#define lowbit(x) ((x)&-(x))
#define pb push_back
#define fi first
#define se second
#define debug(...) fprintf(stderr,__VA_ARGS__)
#define fo(i,l,r) for(register int i=l,_lim_=r;i<=_lim_;i++)
#define fd(i,r,l) for(register int i=r,_lim_=l;i>=_lim_;i--)
#define fos(i,l,r,d) for(register int i=l,_lim_=r;i<=r;i+=d)
#define fol(i,l,r) for(register ll i=l,_lim_=r;i<=_lim_;i++)
#define fdl(i,r,l) for(register ll i=r,_lim_=l;i>=_lim_;i--)
#define fosl(i,l,r,d) for(register ll i=l,_lim_=r;i<=r;i+=d)
#define Clear(a) memset(a,0,sizeof(a))
#define Copy(a,b) memcpy(a,b,sizeof(b))
#define ALL(v) v.begin(),v.end()
#define SZ(v) ((int)v.size())

using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef long double ldb;
typedef double db;
typedef pair<int,int> pi;
template<class T>inline void vnique(vector<T> &r){sort(ALL(r));auto t=unique(ALL(r));r.erase(t,r.end());}

const int N=65,M=1000005,P=1e9+7,dx[]={-1,1,0,0},dy[]={0,0,-1,1};

int n,m,K,a,x[N],y[N],lx,ly,cnt[N][N],s1[M],s2[M],dis[N][N],ql,qr;
bool fb[N][N],mark1[M],mark2[M];
vector<int>px,py;
pi qu[N*N];

void bfs(int x,int y){
    fo(i,0,lx)fo(j,0,ly)dis[i][j]=N<<1;
    dis[x][y]=0;qu[ql=qr=1]={x,y};
    while(ql<=qr){
        int u=qu[ql].fi,v=qu[ql].se;ql++;
        fo(i,0,3){
            int tu=u+dx[i],tv=v+dy[i];
            if(tu>lx||tv>ly||tu<0||tv<0||dis[tu][tv]<=dis[u][v]+1||fb[tu][tv])continue;
            dis[tu][tv]=dis[u][v]+1;qu[++qr]={tu,tv};
        }
    }
}

int main(){
    scanf("%d%d%d",&n,&m,&K);
    px.pb(1);px.pb(n+1);py.pb(1);py.pb(m+1); 
    fo(i,1,n)s1[i]=m;fo(i,1,m)s2[i]=n;
    fo(i,1,K){
        scanf("%d%d",&x[i],&y[i]);
        x[i]++,px.pb(x[i]),px.pb(x[i]+1);
        y[i]++,py.pb(y[i]),py.pb(y[i]+1);
        s1[x[i]]--;mark1[x[i]]=true;
        s2[y[i]]--;mark2[y[i]]=true;
    }
    fo(i,1,n)(s1[i]+=s1[i-1])%=P;fo(i,1,m)(s2[i]+=s2[i-1])%=P;
    fo(i,1,n-1)if(!mark1[i]&&!mark1[i+1])a=(a+(ll)2*s1[i]*(s1[n]-s1[i]))%P;
    fo(i,1,m-1)if(!mark2[i]&&!mark2[i+1])a=(a+(ll)2*s2[i]*(s2[m]-s2[i]))%P;
    vnique(px);vnique(py);lx=SZ(px)-2;ly=SZ(py)-2;
    fo(i,1,K)fb[lower_bound(ALL(px),x[i])-px.begin()][lower_bound(ALL(py),y[i])-py.begin()]=true;
    fo(i,0,lx)fo(j,0,ly)cnt[i][j]=(ll)(px[i+1]-px[i])*(py[j+1]-py[j])%P;
    fo(i,0,lx)fo(j,0,ly)if(!fb[i][j]){
        bfs(i,j);
        fo(k,0,lx)fo(t,0,ly)if(!fb[k][t])a=(a+(ll)cnt[i][j]*dis[k][t]%P*cnt[k][t])%P;
    }
    if(a<0)a+=P;a=(ll)a*(P/2+1)%P;
    printf("%d\n",a);
    return 0;
}

J.

现在有一个由若干1×1×11×1×1的小立方体组成的大小为A×B×CA×B×C的空间(坐标从00开始标号，A,B,C≤100A,B,C≤100)。现在要将空间分成若干个大小为a×b×ca×b×c的环面立方体，其中以 (p,q,r)(p,q,r) 为左下角的环面立方体由所有坐标为(p+imodA,q+jmodB,r+kmodC)(p+imodA,q+jmodB,r+kmodC) 的格子组成，其中 0≤i<a,0≤j<b,0≤k<c0≤i<a,0≤j<b,0≤k<c 。求划分的方案数。

首先考虑 2D2D 的情形，答案很好计算，因为一定有行划分或列划分，只要容斥即可。

当 3D3D 的时候有 trivaltrival 的情况是存在一维的划分，这种情况只要类似 2D2D 一样计算即可。
当情况变得不 trivaltrival 时，我们可以将一维投影，就是说在(p+imodA,q+jmodB,r+kmodC)(p+imodA,q+jmodB,r+kmodC) 上标上 kk 后，计算每层的方案数。实际上我们确定了 z=0z=0 平面的样子就可以确定整个图形的样子了。而这里有个神仙的事情就是不 trivaltrival 的图形的每一层（表示成数字）必然存在行列划分，只有一种划分就可以直接割开，而行列划分就是可以将图剖分成网格一样的小长方形的那种。我们将这个基础的行列划分的一些行或列 shiftshift 若干次， 条件实际上就是对于所有的 zz 至少有行的 shiftshift 也有列的 shiftshift ，于是只要容斥即可。
最后利用 f[p][q]f[p][q] 表示有 pp 行 00 ，qq 行 11 的不 trivaltrival 的图案个数，dpdp 即可。

可以看 w×hw×h 的博客和题解，神仙 w×hw×h 。

估计也没人能看懂。

#include<bits/stdc++.h>

#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-funroll-loops")
#pragma GCC target("avx,sse4")

#define mms(a,n) memset(a,0,sizeof((a)[0])*(n))
#define mmp(a,b,n) memcpy(a,b,sizeof((b)[0])*(n))
#define lowbit(x) ((x)&-(x))
#define pb push_back
#define fi first
#define se second
#define debug(...) fprintf(stderr,__VA_ARGS__)
#define fo(i,l,r) for(register int i=l,_lim_=r;i<=_lim_;i++)
#define fd(i,r,l) for(register int i=r,_lim_=l;i>=_lim_;i--)
#define fos(i,l,r,d) for(register int i=l,_lim_=r;i<=r;i+=d)
#define fol(i,l,r) for(register ll i=l,_lim_=r;i<=_lim_;i++)
#define fdl(i,r,l) for(register ll i=r,_lim_=l;i>=_lim_;i--)
#define fosl(i,l,r,d) for(register ll i=l,_lim_=r;i<=r;i+=d)
#define Clear(a) memset(a,0,sizeof(a))
#define Copy(a,b) memcpy(a,b,sizeof(b))
#define ALL(v) v.begin(),v.end()
#define SZ(v) ((int)v.size())
#define sqr(x) ((x)*(x))

using namespace std;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef long long ll;
typedef long double ldb;
typedef double db;
typedef pair<int,int> pi;
typedef vector<int> VI;
typedef vector<VI> VII;

namespace Main{

const int N=105,P=1e9+7;

inline int fpow(int a,int t){
    static int r;
    for(r=1;t;t>>=1,a=(ll)a*a%P)if(t&1)r=(ll)r*a%P;
    return r;
}

int f[N][N],v[N][N];
int Solve1D(int a,int A){return a;}
int Solve2D(int a,int A,int b,int B){
    return (((ll)a*fpow(Solve1D(b,B),A/a)+(ll)b*fpow(Solve1D(a,A),B/b)-(ll)a*b)%P+P)%P;
}
int Solve3D(int a,int A,int b,int B,int c,int C){
    if(A%a||B%b||C%c)return 0;
    // trival cases
    int ae=A/a,be=B/b,ce=C/c;
    int ret=(
    ((ll)a*fpow(Solve2D(b,B,c,C),ae)
    +(ll)b*fpow(Solve2D(a,A,c,C),be)
    +(ll)c*fpow(Solve2D(a,A,b,B),ce)
    -(ll)a*b*fpow(Solve1D(c,C),ae*be)
    -(ll)a*c*fpow(Solve1D(b,B),ae*ce)
    -(ll)b*c*fpow(Solve1D(a,A),be*ce)
    +(ll)a*b*c)%P+P)%P;
    // non-trival cases
    fo(i,**v=1,max(ae,be))fo(j,*v[i]=1,i)v[i][j]=(v[i-1][j-1]+v[i-1][j])%P;
    fd(i,ae,1)fd(j,be,1){
        f[i][j]=(ll)v[ae][i]*v[be][j]%P*fpow(c,(ae-i)*(be-j))%P;
        fo(k,i,ae)fo(t,j,be)if(k>i||t>j)f[i][j]=(f[i][j]-(ll)f[k][t]*v[k][i]%P*v[t][j]%P+P)%P;
        int p=fpow(b,i),q=fpow(a,j),w=((fpow(p+q-1,ce)-fpow(p,ce)-fpow(q,ce)+1)%P+P)%P;
        if(i<ae||j<be)ret=(ret+(ll)a*b*c*f[i][j]%P*w)%P;
    }
    return ret;
}

}

int a,b,c,A,B,C;

int main(){
    cin>>a>>b>>c>>A>>B>>C;
    cout<<Main::Solve3D(a,A,b,B,c,C);
    return 0;
}
AtCoder Beginner Contest 224题解 A-G
10-24 4355
AtCoder Beginner Contest 224 签到题、简单题 A - Tires 判断一个字符串是不是以er或ist结尾。 直接做即可 #include <bits/stdc++.h> using namespace std; int main() { string s; cin >> s; int n = s.size(); if (n >= 2 && s[n-1]=='r' && s[n-2]=
Atcoder Beginner Contest 132 题解 ( Kevin090228 )
Kevin090228的博客
06-30 917
Atcoder Beginner Contest 132 题解 独家题解，仿冒必究 A - Fifty-Fifty 这题思路很简单，直接用 map<char,int> 统计一下个数，确保每一个都正好出现两次就行了。 注意输出是Yes，不是YES #include<bits/stdc++.h> using namespace std; map<char,int> ...
AtCoder
03-18
AtCoder
【比赛重练】◆AtCoder◆ Peterzavodsk Contest 001
Lucky_Glass的C++之旅
04-05 443
◆AtCoder◆ Peterzavodsk Contest 001 □目录□ ◆AtCoder◆ Peterzavodsk Contest 001 □目录□ □背景□ A- Two Integers ◇原题◇ ◇翻译◇ ◇解析◇ ◇源代码◇ B- Two Arrays ◇原题◇ ◇翻译◇ ◇解析◇ ◇源代码◇ C - Vacant Seat ◇原题◇ ◇翻译◇ ◇解析◇ ...
AtCoder 编程竞赛代码集锦
最新发布
weixin_35756130的博客
05-18 813
AtCoder是一个面向程序员的在线编程竞赛平台，吸引了全世界成千上万的程序员参与。它不仅提供了一个竞赛环境，还允许用户通过参加定期举办的比赛来提高自己的编程技能。AtCoder Beginner Contest (ABC) 是一个面向初学者的比赛，它旨在帮助新手逐步建立起竞赛编程的基础。ABC系列比赛通常包含五个问题，难度从易到难逐步提升。以下是 ABC 系列题目的难度划分，以及如何应对它们：问题A：入门级问题，通常涉及基础算法和数据结构。
【AtCoder】AtCoder Petrozavodsk Contest 001
weixin_30673715的博客
12-05 237
A - Two Integers 如果\(X\)是\(Y\)的倍数的话不存在 可以输出\(X \cdot (\frac{Y}{gcd(X,Y)} - 1)\) 代码 #include <bits/stdc++.h> #define fi first #define se second #define pii pair<int,int> #define pdi pa...
AtCoder - Petrozavodsk - Contest - 001 - D (缩点 + 贪心 + 错误总结）
dreams___的博客
02-06 637
D - Forest Time limit : 2sec / Memory limit : 256MB Score : 600 points Problem Statement You are given a forest with N vertices and M edges. The vertices are numbered 0 through N−1. The edges are
【AtCoder3913】【Peterzavodsk Contest 001 F】XOR Tree（状压DP）
CaptainChen的博客
03-24 400
看了别人的题解，想了半天，我决定把它解释清楚一些。 题目大意 有N(2≤N≤105)N(2≤N≤105)N(2\leq N\leq10^5)个点的树，树边有权值a(0≤a≤15)a(0≤a≤15)a(0\leq a \leq 15)，每次操作可以把树上一条路径上所有边异或一个任意值www，最少多少次操作可以使所有边权都变为000。 题解 用V[u]V[u]V[u]表示把结点uuu的所有边的...
【403 Error】Atcoder Beginner Contest 403 题解
04-28
在ACG（AtCoder Grand Contest）中，【403 Error】Atcoder Beginner Contest 403题解涉及到了数学表达式的转换与计算问题。从给出的内容来看，题解似乎是一组数学等式，每个等式右边展示了数字的分解方式，左边是...
AtCoder Beginner Contest 197 题解（A ~ F）
繁凡さん的博客
04-23 964
前4题都太简单了… 后两题还是很有意思的 至少写起来还是很快乐的
AtCoder Beginner Contest 042题解
你真的介意真的在乎真的想要真的渴望的话你一定能够做到
04-24 602
A - Iroha and Haiku (ABC Edition) 简单模拟即可，判断是否存在两个5一个1。 #include <bits/stdc++.h> using namespace std; int main(){ int A, B, C; cin >> A >> B >> C; int five = 0; int seven = 0; if(A == 5) five++; else if(A == 7)
AtCoder:AtCoder模板
03-27
AtCoder AtCoder模板和我在C＃中的解决方法
AtCoder库-C/C++开发
05-27
AC库是AtCoder的官方库。 该存储库管理AC库的内容。 AC（AtCoder）库AC库是AtCoder的官方库。 该存储库管理AC库的内容。 您可以参考以下链接以获取更多详细信息：关于AtCoder的公告关于Codeforces实践竞赛的公告AC库文档（en）AC库文档（ja）政策我们的项目目标是使每个AtCoder用户都能使用该库只需花费很少的精力就可以学习PC，从而最大程度地提高了在竞争性编程中的使用便利性。
atcoder
qq_45772483的博客
08-22 249
Problem Statement A maze is composed of a grid of H × W squares - H vertical, W horizontal. The square at the i -th row from the top and the j -th column from the left - ( i , j ) is a wall if S i j is # and a road if S i j is … There is a magician in (
AtCoder：Hamiltonish Path（思维 & dfs）
junior19的博客
05-13 647
B - Hamiltonish Path Time limit : 2sec / Memory limit : 256MB Score : 500 points Problem Statement You are given a connected undirected simple graph, which has N vertices and M edges
AtCoder：AtCoder Group Contest（思维）
junior19的博客
05-08 598
A - AtCoder Group Contest Time limit : 2sec / Memory limit : 256MB Score : 300 points Problem Statement There are 3N participants in AtCoder Group Contest. The strength of the i-th p
【AtCoder】（AtCoder Grand Contest 006）D - Median Pyramid Hard
Pure_W的博客
03-02 1174
【AtCoder】（AtCoder Grand Contest 006）D - Median Pyramid Hard 传送门：http://agc006.contest.atcoder.jp/tasks/agc006_d 刚开始不懂，去找大坏人，被告知是套路题。瞬间想到二分后转变为01的问题。 然后又想了很久……（发现还是不懂） 结果被路过的魏爷戳懂了……
AtCoder - 3916 Simple APSP Problem
Welcome to yjjr's blog!
04-03 475
标签：bfs 题目 题目传送门 给定一个w×hw×hw\times h的网格，网格之间有1的边权。上面有n≤30n≤30n\leq 30个位置有障碍，网格大小 10610610^6，求所有非障碍点对间的最短路之和。 分析 把没有状态的两行或者两列压缩到一起，我们发现没有障碍的行和列出去的最短路一定是相同的（或者说对答案的影响是等价的） 计算出中间的边经过的次数然后合并 然后对周围...
AtCoder 195 B，C，D
睡神的博客
03-22 427
AtCoder 195 https://atcoder.jp/contests/abc195/tasks C - Comma c题题面很简单，就是三位一断，加逗号。问1到n这些数中，一共要加多少个逗号？翻跟没翻差别不大 n是<=10^5，所以可以直接暴力。 D - Shipping Center 我们有n个背包，m个盒子。每个背包都会有个容量和价值，每一个box也会有一个容量。然后会有q个查询，每个查询中，都会给个l,r，意思是这个区间的box都不可用，问用剩余盒子装出的最大价值为多少？
AtCoder Beginner Contest 134 简要题解
05-23
AtCoder Beginner Contest 134 是一场 AtCoder 的入门级比赛，以下是每道题的简要题解： A - Dodecagon 题目描述：已知一个正十二边形的边长，求它的面积。 解题思路：正十二边形的内角为 $150^\circ$，因此可以将正十二边形拆分为 12 个等腰三角形，通过三角形面积公式计算面积即可。 B - Golden Apple 题目描述：有 $N$ 个苹果和 $D$ 个盘子，每个盘子最多可以装下 $2D+1$ 个苹果，求最少需要多少个盘子才能装下所有的苹果。 解题思路：每个盘子最多可以装下 $2D+1$ 个苹果，因此可以将苹果平均分配到每个盘子中，可以得到最少需要 $\lceil \frac{N}{2D+1} \rceil$ 个盘子。 C - Exception Handling 题目描述：给定一个长度为 $N$ 的整数序列 $a$，求除了第 $i$ 个数以外的最大值。 解题思路：可以使用两个变量 $m_1$ 和 $m_2$ 分别记录最大值和次大值。遍历整个序列，当当前数不是第 $i$ 个数时，更新最大值和次大值。因此，最后的结果应该是 $m_1$ 或 $m_2$ 中较小的一个。 D - Preparing Boxes 题目描述：有 $N$ 个盒子和 $M$ 个物品，第 $i$ 个盒子可以放入 $a_i$ 个物品，每个物品只能放在一个盒子中。现在需要将所有的物品放入盒子中，每次操作可以将一个盒子内的物品全部取出并分配到其他盒子中，求最少需要多少次操作才能完成任务。 解题思路：首先可以计算出所有盒子中物品的总数 $S$，然后判断是否存在一个盒子的物品数量大于 $\lceil \frac{S}{2} \rceil$，如果存在，则无法完成任务。否则，可以用贪心的思想，每次从物品数量最多的盒子中取出一个物品，放入物品数量最少的盒子中。因为每次操作都会使得物品数量最多的盒子的物品数量减少，而物品数量最少的盒子的物品数量不变或增加，因此这种贪心策略可以保证最少需要的操作次数最小。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值