ICPC2021（沈阳）

大概只能做出六七道的样子，菜菜的我也只能提供B、E、F、H、J、L几道题的题解啦。

B Bitwise Exclusive-OR Sequence

题目大意：给你n个数和m个关系，每个关系要求两个数$a_i\oplus b_i=m_i$,然后求解所以满足要求的n个数中${\sum }_{i=1}^n{a}_i$的最小值是多少。$(n\le 10^5,m\le 2\times 10^5)$
容易发现每个联通块中只要填好一个数，其它数的值也就唯一确定了，我们只需要按位枚举每个联通块中任意一个点的数值即可，因为位与位之间的异或值不会产生影响，故每一位都取最小值即可得到整体的最小值。

#include<iostream>
#include<cstdio>
#include<string>
#include<iostream>
#include<cstring>
#define int long long
#define maxn 1000005
using namespace std;
int read()
{
int x=1,res=0;
char c=getchar();
while(c<'0'||c>'9')
{
if(c=='-')
x=-1;
c=getchar();
}
while(c>='0'&&c<='9')
{
res=res*10+(c-'0');
c=getchar();
}
return res*x;
}
struct edge{
int next,to,dis;
}g[maxn<<1];
int n,m,aa,bb,cc,num,col,a[35],ans,pd;
int last[maxn],vis[maxn],f[maxn];
void add(int from,int to,int dis)
{
g[++num].next=last[from];
g[num].to=to;
g[num].dis=dis;
last[from]=num;
}
void dfs(int x,int val)
{
vis[x]=1;col++;f[x]=val;
for(int i=0;i<=30;i++)
a[i]+=(val>>i)&1;
for(int i=last[x];i;i=g[i].next)
{
int v=g[i].to;
if(vis[v]&&(f[x]^f[v])!=g[i].dis)
{
pd=1;
}
if(!vis[v])
dfs(v,val^g[i].dis);
}
}
signed main()
{
n=read();m=read();
for(int i=1;i<=m;i++)
{
aa=read();bb=read();cc=read();
add(aa,bb,cc);
add(bb,aa,cc);
}
memset(vis,0,sizeof(vis));
for(int j=1;j<=n;j++)
{
if(vis[j]) continue;
memset(a,0,sizeof a);
col=0;
dfs(j,0);
for(int i=0;i<=30;i++)
{
ans+=min(col-a[i],a[i])*(1<<i);
}
}
if(pd==1) puts("-1");
else cout<<ans;
return 0;
}

E Edward Gaming, the Champion

题目大意，给定一个字符串，判断含有多少个edgnb。签到题。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
string a;
int ans;
int main()
{
cin>>a;
int len=a.size();
for(int i=0;i<=len-5;i++)
{
if(a[i]=='e'&&a[i+1]=='d'&&a[i+2]=='g'&&a[i+3]=='n'&&a[i+4]=='b')
ans++;
}
cout<<ans;
return 0;
}

F Encoded Strings I

题目大意：给你一个字符串，按照题目要求对该字符串的每一个前缀串进行变换，输出所有变换后的串中字典序最大的一个字符串。具体变换规则为：一个字符它最后出现的位置后有$i$个不同的字符，那么该字符就应该变换成第$i+1$个字符。简单模拟即可

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#define int long long
#define maxn 1005
using namespace std;
int n;
string a,b,c;
int f[maxn];
void solve(int x)
{
int cnt=0;memset(f,0,sizeof(f));b.clear();
for(int i=x;i>=0;i--)
{
if(f[a[i]-'a']) continue;
f[a[i]-'a']=++cnt;
}
for(int i=0;i<=x;i++)
{
b.insert(i,1,char(f[a[i]-'a']+'a'-1));
}
}
signed main()
{
cin>>n;cin>>a;c="a";
for(int i=0;i<n;i++)
{
solve(i);
if(b>c) c=b;
}
cout<<c<<endl;
}

J Luggage Lock

题目大意：给你一个四位密码锁，求最少多少次操作可以从起始状态转到目标状态。
对于每次询问如果直接bfs时间复杂度为$O(10^4\times T)$很难在给定的时间限制内给出答案，但是我们发现从起始状态转移到目标状态相当于每位加或减一个数，而且如果每位进行的操作都相同时，答案一定相同，因此我们可以将起始状态和目标状态同时减去起始状态的数值，即(a,b)~(0,b-a)这样我们只需要知道从0开始到所有状态的操作次数即可，时间复杂度$O(10^4+T)$

#include<iostream>
#include<cstdio>
#include<string>
#include<queue>
#define int long long
#define maxn 1000005
using namespace std;
int read()
{
int x=1,res=0;
char c=getchar();
while(c<'0'||c>'9')
{
if(c=='-')
x=-1;
c=getchar();
}
while(c>='0'&&c<='9')
{
res=res*10+(c-'0');
c=getchar();
}
return res*x;
}
struct node{
int a1,a2,a3,a4,cnt;
};
int t,aa,bb,a[5],vis[10][10][10][10],f[10005];
queue<node>q;
int cal(int a,int b,int c,int d)
{
return a+b*10+c*100+d*1000;
}
void bfs(){
q.push((node){0,0,0,0,0});
while(q.size())
{
node u=q.front();
q.pop();
if(vis[u.a1][u.a2][u.a3][u.a4]) continue;
f[cal(u.a1,u.a2,u.a3,u.a4)]=u.cnt;
vis[u.a1][u.a2][u.a3][u.a4]=1;
int a=u.a1,b=u.a2,c=u.a3,d=u.a4,cnt=u.cnt;
//1
q.push((node){(a+1)%10,b,c,d,cnt+1});
q.push((node){(a+9)%10,b,c,d,cnt+1});
q.push((node){a,(b+1)%10,c,d,cnt+1});
q.push((node){a,(b+9)%10,c,d,cnt+1});
q.push((node){a,b,(c+1)%10,d,cnt+1});
q.push((node){a,b,(c+9)%10,d,cnt+1});
q.push((node){a,b,c,(d+1)%10,cnt+1});
q.push((node){a,b,c,(d+9)%10,cnt+1});
//2
q.push((node){(a+1)%10,(b+1)%10,c,d,cnt+1});
q.push((node){(a+9)%10,(b+9)%10,c,d,cnt+1});
q.push((node){a,(b+1)%10,(c+1)%10,d,cnt+1});
q.push((node){a,(b+9)%10,(c+9)%10,d,cnt+1});
q.push((node){a,b,(c+1)%10,(d+1)%10,cnt+1});
q.push((node){a,b,(c+9)%10,(d+9)%10,cnt+1});
//3
q.push((node){(a+1)%10,(b+1)%10,(c+1)%10,d,cnt+1});
q.push((node){(a+9)%10,(b+9)%10,(c+9)%10,d,cnt+1});
q.push((node){a,(b+1)%10,(c+1)%10,(d+1)%10,cnt+1});
q.push((node){a,(b+9)%10,(c+9)%10,(d+9)%10,cnt+1});
//4
q.push((node){(a+1)%10,(b+1)%10,(c+1)%10,(d+1)%10,cnt+1});
q.push((node){(a+9)%10,(b+9)%10,(c+9)%10,(d+9)%10,cnt+1});
}
}
signed main()
{
t=read();
bfs();
while(t--)
{
aa=read();bb=read();
a[1]=(bb%10-aa%10+10)%10;
a[2]=(bb/10%10-aa/10%10+10)%10;
a[3]=(bb/100%10-aa/100%10+10)%10;
a[4]=(bb/1000%10-aa/1000%10+10)%10;
printf("%dn",f[cal(a[1],a[2],a[3],a[4])]);
}
}

L Perfect Matchings

题目大意：给你一个完全图和该图中的一颗生成树，问不包括树边的边独立集的数目有多少。
题解：首先我们容易发现对于一个点数为$2n$的完全图，边独立集数目为$sum={\prod }_{i=1}^n(2\times i-1)$，因此我们可以考虑采用容斥原理，问题转化为求含有树边的边独立集的数目，其次，如果我们选出了一些树边，那么剩下的点依旧能够形成一张完全图，这样我们就只需要求解树边的选取方案数即可，但这样做问题在于我们会选出重复的树边，因为当选取一些树边时，剩余结点形成的完全图中仍然还剩有树边，而通过完全图得到的结果显然会比答案要大，当我们选择$i$条树边时，用上述方法求得的答案会多$C_k^i$个选$k(k>i)$条树边的方案，不难看出选奇数条树边的方案数$\ast$剩余完全图选边方案数-选偶数条树边的方案数$\ast$剩余完全图选边方案数即为不符合题意的方案数，而求解选取树边的方案数可以通过树形dp实现，我们设$f[i][j][1/0]$表示以$i$为根的子树选$j$条树边选或不选自己的方案数，则
$$\begin{gathered} f[x][k][0]=f[x][k][0]+f[x][k-j][0]\ast (f[v][j][0]+f[v][j][1]) \\ f[x][k][1]=f[x][k][1]+f[x][k-j][1]\ast (f[v][j][0]+f[v][j][1]) \\ f[x][k][1]=f[x][k][1]+f[x][k-j][0]\ast f[v][j-1][0] \end{gathered}$$
然而这样的时间复杂度为$O(n^3)$,我们可以通过统计每一个子树的大小来对dp进行优化，时间复杂度均摊为$O(n^2)$

#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#define int long long
#define maxn 4005
#define mod 998244353
using namespace std;
int read()
{
int x=1,res=0;
char c=getchar();
while(c<'0'||c>'9')
{
if(c=='-')
x=-1;
c=getchar();
}
while(c>='0'&&c<='9')
{
res=res*10+(c-'0');
c=getchar();
}
return res*x;
}
struct edge{
int next,to;
}g[maxn<<1];
int f[maxn][maxn][2],aa,bb,ans;
int n,num,last[maxn],sum[maxn],sz[maxn],vis[maxn];
void add(int from,int to)
{
g[++num].next=last[from];
g[num].to=to;
last[from]=num;
}
void dfs1(int x,int fa)
{
sz[x]=1;
for(int i=last[x];i;i=g[i].next)
{
int v=g[i].to;
if(v!=fa)
{
dfs1(v,x);
sz[x]+=sz[v];
}
}
}
void dfs(int x)
{
vis[x]=1;f[x][0][0]=1;
for(int i=last[x];i;i=g[i].next)
{
int v=g[i].to;
if(!vis[v])
{
dfs(v);
for(int k=sz[x]/2;k>=1;k--)
{
for(int j=max(1ll,k+sz[v]/2-sz[x]/2);j<=min(sz[v]/2+1,k);j++)
{
f[x][k][0]=(f[x][k][0]+(f[x][k-j][0]*(f[v][j][0]+f[v][j][1])%mod))%mod;
f[x][k][1]=(f[x][k][1]+(f[x][k-j][1]*(f[v][j][0]+f[v][j][1])%mod))%mod;
f[x][k][1]=(f[x][k][1]+(f[x][k-j][0]*f[v][j-1][0])%mod)%mod;
}
}
}
}
}
signed main()
{
n=read();sum[1]=1;sum[0]=1;
for(int i=2;i<=n;i++) sum[i]=sum[i-1]*(2*i-1)%mod;
for(int i=1;i<=(2*n-1);i++)
{
aa=read();bb=read();
add(aa,bb);
add(bb,aa);
}
dfs1(1,0);
dfs(1);
ans=sum[n];
for(int i=1;i<=n;i++)
{
if(i%2==1) ans=(ans-(f[1][i][0]+f[1][i][1])*sum[n-i]%mod+mod)%mod;
else ans=(ans+(f[1][i][0]+f[1][i][1])*sum[n-i]%mod+mod)%mod;
}
cout<<ans%mod;
return 0;
}

H Line Graph Matching

题目大意：给你一个无向连通图，每次可以选取与一个顶点的相连的两条边并得到两条边的权值，得到的最大权值是多少。
题解：不难看出，当边数为偶数时，存在方案使得所以边都可以取完，答案即为边的权值之和，而边数为奇数时，我们必须要舍去一条边不去选，如果删除这条边后图依然连通，那么这个边就可以不选然后将其他边全选，而如果这条边是图的一条割边，我们就需要统计一些割边连通的两个非连通图的边数，如果都为偶数那么这条边就可以不选，如果都为奇数那么两个非连通图中必然又要有一些边不能选，如果这样答案一定不是最优解，直接舍去就可以，所以我们只需要删去一条非割边的边或者两侧的图都是有偶数条边的割边之中的权值最小的边即可，可以用tarjan算法求出割边，在tarjan过程中我们可以维护一下以某个点为根的子树的边数，而边数可以通过点的入度$\sum de[i]/2$得到。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#define int long long
#define maxn 400005
using namespace std;
struct edge{
int next,to,dis;
}g[maxn];
int dfn[maxn],low[maxn],num=1,last[maxn],n,m,c,tot,ans=2e9,a;
int bridge[maxn],aa,bb,cc,vis[maxn],de[maxn],sz1[maxn],sz2[maxn];
int read()
{
int res=0,x=1;
char c=getchar();
while(c<'0'||c>'9')
{
if(c=='-')
x=-1;
c=getchar();
}
while(c>='0'&&c<='9')
{
res=res*10+(c-'0');
c=getchar();
}
return res*x;
}
void add(int from,int to,int dis)
{
g[++num].next=last[from];
g[num].to=to;
g[num].dis=dis;
last[from]=num;
}
void tarjan(int u,int id)
{
dfn[u]=low[u]=++tot;
for(int i=last[u];i;i=g[i].next)
{
int v=g[i].to;
if(!dfn[v])
{
tarjan(v,i);
low[u]=min(low[u],low[v]);
if(low[v]>dfn[u])
{
sz1[i]=sz1[i^1]=(de[v]-1)/2;
sz2[i]=sz2[i^1]=m-sz1[i]-1;
bridge[i]=bridge[i^1]=1;
}
de[u]+=de[v];
}
else if((i^id)!=1)
low[u]=min(low[u],dfn[v]);
}
}
signed main()
{
n=read();m=read();
for(int i=1;i<=m;i++)
{
aa=read();bb=read();cc=read();
a+=cc;de[aa]++;de[bb]++;
add(aa,bb,cc);
add(bb,aa,cc);
}
if(m%2==0)
{
cout<<a<<endl;
return 0;
}
tarjan(1,0);
for(int j=1;j<=n;j++)
for(int i=last[j];i;i=g[i].next)
{
if(bridge[i]==0) ans=min(ans,g[i].dis);
else if((sz1[i])%2==0&&(sz2[i])%2==0) ans=min(ans,g[i].dis);
}
cout<<a-ans;
return 0;
}

最后

以上就是无奈老虎为你收集整理的ICPC2021（沈阳）的全部内容，希望文章能够帮你解决ICPC2021（沈阳）所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。