【CodeForces】CodeForcesRound594 Div1 解题报告

标签：type   %s   难点   city   时间   puts   记录   认识自己   tarjan   

点此进入比赛

\(A\)：Ivan the Fool and the Probability Theory（点此看题面）

大致题意： 给一个$n\times m$的矩阵$01$染色，使得不存在某个同色连通块大小超过$2$。

这道题看似很神仙，实际上仔细想一想、推一推性质，还是比较简单的。

先考虑第一行，这是一个$1\times m$的矩阵，可以设$f_{i,0/1}$为第$i$个格子所填与上个格子不同/相同的方案数，则：\(f_{i,0}=f_{i-1,0}+f_{i-1,1},f_{i,1}=f_{i-1,0}\)。

由于第一个位置可填$0$可填$1$，所以初始化$f_{1,0}=2,f_{1,1}=0$。

接下来，我们考虑从第一行向下扩展，分两种情况讨论：

• 如果第一行不存在连续两个格子所填相同，则每一行填的数只能与上一行完全相反或是完全相同，且不能有连续超过$2$行完全相同。此时第一行只有$0101...01$或$1010...10$两种情况，而若我们把$0101...01$看作$0$，$1010...10$看作$1$，那么就相当于对$n\times 1$的矩阵$01$染色，所以方案数为$f_{n,0}+f_{n,1}$。
• 如果第一行存在连续的两个格子所填相同，则每一行填的数只能与上一行完全相反。此时第一行有$f_{m,0}+f_{m,1}-2$种填法（除去第一行不存在连续两个格子所填相同的两种填法），每种第一行填法对应唯一一种全局填法，所以方案数为$f_{m,0}+f_{m,1}-2$。

综上所述，总方案数为$f_{n,0}+f_{n,1}+f_{m,0}+f_{m,1}-2$。

#include<bits/stdc++.h>
#define Tp template<typename Ty>
#define Ts template<typename Ty,typename... Ar>
#define Reg register
#define RI Reg int
#define Con const
#define CI Con int&
#define I inline
#define W while
#define N 100000
#define X 1000000007
using namespace std;
int n,m,f[N+5][2];
I int Qpow(RI x,RI y) {RI t=1;W(y) y&1&&(t=1LL*t*x%X),x=1LL*x*x%X,y>>=1;return t;}
int main()
{
	RI i;scanf("%d%d",&n,&m);
	for(f[1][0]=2,i=2;i<=max(n,m);++i) f[i][0]=(f[i-1][0]+f[i-1][1])%X,f[i][1]=f[i-1][0];
	return printf("%d",(1LL*f[n][0]+f[n][1]+f[m][0]+f[m][1]-2+X)%X),0;
}

\(B\)：The World Is Just a Programming Task (Hard Version)（点此看题面）

大致题意： 定义一个括号序列$S$的美丽值为有多少个$p$使能得$S_{p,n}S_{1,p-1}$为合法括号序列。现在你可以交换一个括号序列中两个括号，求所能得到的最大的美丽值及交换的位置。

细节巨多的题目，写了一个下午......

首先，如果$S$的左右括号数量不同，直接输出$0$和$1\ 1$走人。

然后，我们考虑，对于一个括号序列，它的美丽值的意义。然后不难推导出，如果我们把(看作$1$，)看作$-1$，求出前缀和$s$数组后，美丽值就是**$s$中的最小值个数**。

假设我们交换括号$x,y(x<y)$，$s$中原本的最小值为$Mn$。

我的做法是，先对于$x$是左括号还是右括号进行讨论，然后再分别继续处理。

• 对于$x$是左括号的情况。此时，就相当于$s_{x\sim y-1}$减去$2$。
  • 如果$s_{x\sim y-1}$中的最小值是$Mn$，则操作后$s$中的最小值是$Mn-2$。显然答案不会更优。
  • 如果$s_{x\sim y-1}$中的最小值是$Mn+1$，则操作后$s$中的最小值是$Mn-1$。答案就是$s_{x\sim y-1}$中$Mn+1$的个数。
  • 如果$s_{x\sim y-1}$中的最小值是$Mn+2$，则操作后$s$中的最小值依然是$Mn-2$。答案就是$s_{x\sim y-1}$中$Mn+2$的个数加上整个$s$中$Mn$的个数。
• 对于$x$是右括号的情况。此时，就相当于$s_{x\sim y-1}$加上$2$，也就是$s_{1\sim x-1},s_{y\sim n}$减去$2$，随后的讨论与上面类似。

通过上面的讨论，不难发现，在最小值不变的情况下，变化区间肯定是范围越大越好，因此我们用两个双指针来维护出最小值为$Mn+1,Mn+2$的两个答案区间即可。

具体实现可能有些细节要注意，可详见代码。

#include<bits/stdc++.h>
#define Tp template<typename Ty>
#define Ts template<typename Ty,typename... Ar>
#define Reg register
#define RI Reg int
#define Con cosnt
#define CI Con int&
#define I inline
#define W while
#define N 300000
using namespace std;
int n,a[N+5],p[N+5];char s[N+5];
int main()
{
	RI i,Mn=n,res=0,ans=0,tx=1,ty=1;for(scanf("%d%s",&n,s+1),i=1;i<=n;++i)//读入+转化
		a[i]=s[i]==‘(‘?1:-1,p[i]=p[i-1]+a[i],Mn>p[i]?(Mn=p[i],res=1):Mn==p[i]&&++res;
	if(p[n]) return puts("0\n 1 1"),0;ans=res;RI t=0,g=0;//如果左右括号数量不同，直接输出
	RI nxt1=n,nxt2=n;for(i=n-1;i;--i)//对于左边是左括号
		p[i]==Mn?(t=0,nxt1=i):(t+=p[i]==Mn+1),//维护最小值是Mn+1的答案区间
		(p[i]==Mn||p[i]==Mn+1)?(g=0,nxt2=i):(g+=p[i]==Mn+2),//维护最小值是Mn+2的答案区间
		~a[i]&&(ans<t&&(ans=t,tx=i,ty=nxt1),ans<res+g&&(ans=res+g,tx=i,ty=nxt2));//更新答案
	RI v=0,w=0,k=0;for(t=g=0,i=1;i<=n;++i) p[i]==Mn+1&&++t,p[i]==Mn+2&&++g;//初始化
	RI lim=t;for(nxt1=nxt2=i=1;i<=n;++i)//对于左边是右括号
	{
		W(v^res) p[nxt1]==Mn&&++v,p[nxt1]==Mn+1&&--t,nxt1=nxt1%n+1;//维护最小值是Mn+1的答案区间
		W(w^lim||k^res) p[nxt2]==Mn+1&&++w,p[nxt2]==Mn&&++k,p[nxt2]==Mn+2&&--g,nxt2=nxt2%n+1;//维护最小值是Mn+2的答案区间
		!~a[i]&&ans<t&&(ans=t,tx=i,ty=nxt1),p[i]==Mn&&--v,p[i]==Mn+1&&++t,//更新最小值是Mn+1的答案，然后更新区间
		!~a[i]&&ans<res+g&&(ans=res+g,tx=i,ty=nxt2),p[i]==Mn+1&&--w,p[i]==Mn&&--k,p[i]==Mn+2&&++g;//更新最小值是Mn+2的答案，然后更新区间
	}
	return printf("%d\n%d %d",ans,tx,ty),0;//输出答案
}

\(C\)：Queue in the Train（点此看题面）

大致题意： 有$n$个人要灌水，每个人灌水用时皆为一个定值。每个人会在第$p_i$刻开始想要灌水，如果大于等于$p_i$的某一时刻他前方没有人在排队，他就会去排队。求每个人灌完水的时间。

模拟题，一开始理解错几个细节就挂飞了......

其实这道题说简单也很简单，个人认为我的做法可能有点复杂......

首先，我们把人以开始灌水时间为第一关键字、编号为第二关键字，排序，并用一个指针$i$来表示排序后的前$i$个人当前能够灌水。

然后，我们开一个小根堆（优先队列），把当前能够灌水的人都扔到堆里。

扔的同时，我们要判断这个人是否能去排队了，这只需要判断他之前是否有人去排队了，因此我写了一个树状数组。

如果能排队，我们就把它扔到一个队列里，果然是排队。

还有一些细节自己注意一下吧，下面放出代码以供参考。

#include<bits/stdc++.h>
#define Tp template<typename Ty>
#define Ts template<typename Ty,typename... Ar>
#define Reg register
#define RI Reg int
#define Con const
#define CI Con int&
#define I inline
#define W while
#define N 100000
#define LL long long
using namespace std;
int n,m,a[N+5];LL ans[N+5];queue<int> q;
struct data
{
	int p,v;I data(CI x=0,CI y=0):p(x),v(y){}
	I bool operator < (Con data& o) Con {return v^o.v?v<o.v:p<o.p;}
}s[N+5];priority_queue<int,vector<int>,greater<int> > p;
class FastIO
{
	private:
		#define FS 100000
		#define tc() (A==B&&(B=(A=FI)+fread(FI,1,FS,stdin),A==B)?EOF:*A++)
		#define pc(c) (C==E&&(clear(),0),*C++=c)
		#define tn (x<<3)+(x<<1)
		#define D isdigit(c=tc())
		int T;char c,*A,*B,*C,*E,FI[FS],FO[FS],S[FS];
	public:
		I FastIO() {A=B=FI,C=FO,E=FO+FS;}
		Tp I void read(Ty& x) {x=0;W(!D);W(x=tn+(c&15),D);}
		Tp I void write(Ty x) {W(S[++T]=x%10+48,x/=10);W(T) pc(S[T--]);}
		Tp I void write(Con Ty& x,Con char& y) {write(x),pc(y);}
		I void clear() {fwrite(FO,1,C-FO,stdout),C=FO;}
}F;
class TreeArray//树状数组
{
	private:
		int v[N+5];
	public:
		I void Add(RI x,CI y) {W(x<=n) v[x]+=y,x+=x&-x;}//后缀修改
		I int Qry(RI x,RI t=0) {W(x) t+=v[x],x-=x&-x;return t;}//单点查询
}T;
int main()
{
	RI i,f;LL t=0;for(F.read(n),F.read(m),i=1;i<=n;++i) F.read(a[i]),s[i]=data(i,a[i]);
	sort(s+1,s+n+1),i=1;W(i<=n||!p.empty()||!q.empty())
	{
		!(f=q.empty())&&(ans[q.front()]=(t+=m)),i<=n&&p.empty()&&q.empty()&&(t=s[i].v);//计算当前时间
		W(!p.empty()&&!T.Qry(p.top())) q.push(p.top()),T.Add(p.top()+1,1),p.pop();//处理原有能够灌水的人
		W(i<=n&&s[i].v<=t) p.push(s[i++].p),!T.Qry(p.top())&&(q.push(p.top()),T.Add(p.top()+1,1),p.pop(),0);//处理新增能够灌水的人，同时判断是否能去排队
		!f&&(T.Add(q.front()+1,-1),q.pop(),0);//当前正在灌水的人已经灌完
	}
	for(i=1;i<=n;++i) F.write(ans[i]," \n"[i==n]);return F.clear(),0;//输出答案
}

\(D\)：Catowice City（点此看题面）

大致题意： 有$n$个人，每人有一只猫。每个人都认识若干猫（一定认识自己的猫），现在要选出人和猫共$n$个，使得至少有一个人和一只猫，且每个人都不认识任何一只猫。

首先，我们可以发现，因为一个人一定认识自己的猫，所以一个数不可能被选两次。而题目要求选出$n$个数，就必然是把$1\sim n$分成两部分。

则，我们考虑如果选择了编号为$i$的人，那么他认识的所有的猫的主人都必须被选择，而他认识的猫的主人认识的猫的主人同样也都必须被选择，以此类推。

如果我们把编号为$i$的人认识编号为$j$的猫看作一条有向边，那么选择一个人，就相当于选择了从这个点出发能够到达的所有点。

因此，我们用$Tarjan$将图缩点，显然，如果原图只有一个强连通分量，就会输出$No$，否则必然输出$Yes$。

考虑如果我们选择一个强连通分量中的点作为人，如果这个强连通分量出度为$0$，是肯定合法的。而根据$Tarjan$的原理可知，$Tarjan$过程中得到的第一个强连通分量，出度是必然为$0$的。

因此我们只要把编号为$1$的强连通分量中的点作为人，剩余点作为猫，即可满足题目要求了。

#include<bits/stdc++.h>
#define Tp template<typename Ty>
#define Ts template<typename Ty,typename... Ar>
#define Reg register
#define RI Reg int
#define Con const
#define CI Con int&
#define I inline
#define W while
#define N 1000000
#define add(x,y) (e[++ee].nxt=lnk[x],e[lnk[x]=ee].to=y)
#define Gmin(x,y) (x>(y)&&(x=(y)))
using namespace std;
int n,m,ee,d,cnt,T,lnk[N+5],dfn[N+5],low[N+5],col[N+5],vis[N+5],S[N+5],Sz[N+5];
struct edge {int to,nxt;}e[N+5];
class FastIO
{
	private:
		#define FS 100000
		#define tc() (A==B&&(B=(A=FI)+fread(FI,1,FS,stdin),A==B)?EOF:*A++)
		#define pc(c) (C==E&&(clear(),0),*C++=c)
		#define tn (x<<3)+(x<<1)
		#define D isdigit(c=tc())
		int T;char c,*A,*B,*C,*E,FI[FS],FO[FS],S[FS];
	public:
		I FastIO() {A=B=FI,C=FO,E=FO+FS;}
		Tp I void read(Ty& x) {x=0;W(!D);W(x=tn+(c&15),D);}
		Tp I void write(Ty x) {W(S[++T]=x%10+48,x/=10);W(T) pc(S[T--]);}
		Tp I void write(Con Ty& x,Con char& y) {write(x),pc(y);}
		I void writes(Con string& x) {for(RI i=0,y=x.length();i^y;++i) pc(x[i]);}
		I void clear() {fwrite(FO,1,C-FO,stdout),C=FO;}
}F;
I void Tarjan(CI x,CI lst)//Tarjan缩点
{
	dfn[x]=low[x]=++d,vis[S[++T]=x]=1;for(RI i=lnk[x];i;i=e[i].nxt) dfn[e[i].to]?
		vis[e[i].to]&&Gmin(low[x],dfn[e[i].to]):(Tarjan(e[i].to,x),Gmin(low[x],low[e[i].to]));
	if(dfn[x]^low[x]) return;Sz[col[x]=++cnt]=1,vis[x]=0;
	W(S[T]^x) ++Sz[col[S[T]]=cnt],vis[S[T--]]=0;--T;
}
int main()
{
	RI Tt,i,j,x,y;F.read(Tt);W(Tt--)
	{
		for(F.read(n),F.read(m),ee=d=cnt=0,i=1;i<=n;++i) lnk[i]=dfn[i]=vis[i]=0;//清空
		for(i=1;i<=m;++i) F.read(x),F.read(y),x^y&&add(x,y);//连边
		for(i=1;i<=n;++i) !dfn[i]&&(Tarjan(i,0),0);//Tarjan缩点
		if(cnt==1) {F.writes("No\n");continue;}F.writes("Yes\n");//判断是否有解
		F.write(Sz[1],‘ ‘),F.write(n-Sz[1],‘\n‘);//分别输出人与猫的个数
		for(i=1;i<=n;++i) col[i]==1&&(F.write(i,‘ ‘),0);F.writes("\n");//输出强连通分量内的点，作为人
		for(i=1;i<=n;++i) col[i]^1&&(F.write(i,‘ ‘),0);F.writes("\n");//输出剩余的点，作为猫
	}return F.clear(),0;
}

\(E\)：Turtle（点此看题面）

大致题意： 让你把$2n$个元素放到一个$2\times n$的矩阵中，使得从左上角走到右下角（只能往下或往右）所经元素总和的最大值最小。

因为只能往下或往右走，所以我们可以找到一个关键点$p$，使得在$p$点之前在第一行走，$p$点之后在第二行走，$p$点从第一行到第二行。

设所经元素总和为$f(p)=\sum_{i=1}^pa_{1,i}+\sum_{i=p}^na_{2,i}$。

根据贪心，显而易见，第一排的数应当递增摆放，第二排的数应当递减摆放。

考虑将$p$从$1$移动到$n$，则每次移动，元素总和发生的变化其实都是加上$a_{1,p+1}-a_{2,p}$。由于第一排递增，第二排递减，则$a_{1,p+1}-a_{2,p}$也是递增的。

假设当$p=x$时满足使$f(p)$最大的同时$x$最大，则我们可以得到结论：$x=1$或$x=n$。

当$x≠1$且$x≠n$时，\(\because f(x)=f(x-1)+a_{1,x}-a_{2,x-1},f(x)\ge f(x-1),\therefore a_{1,x}-a_{2,x-1}\ge0.\)

又$\because a_{1,x+1}-a_{2,x}\ge a_{1,x}-a_{2,x-1},\therefore a_{1,x+1}-a_{2,x}\ge 0.$

\(\therefore f(x+1)=f(x)+a_{1,x+1}-a_{2,x}\ge f(x).\)

这与$p=x$时满足使$f(p)$最大的同时$x$最大矛盾，$\therefore x=1$或$x=n.$

也就是说，最大值应该是$max(f(1),f(n))$，即$max(a_{1,1}+\sum_{i=1}^na_{2,i},\sum_{i=1}^na_{1,i}+a_{2,n})$。

如果我们同时从两个式子中拿出$a_{1,1}$和$a_{2,n}$，就得到：\(a_{1,1}+a_{2,n}+max(\sum_{i=1}^{n-1}a_{2,i},\sum_{i=2}^na_{1,i})\)。

由于$a_{1,1}$和$a_{2,n}$无论如何都会被取到，显然它们两个应该分别填上最小值和次小值。

那么，题目也就变成了，将剩余的$2n-2$个数分成两个大小为$n-1$的集合，使得两个集合内数总和的较大值最小。

所以，我们可以先通过背包来求出这个答案。

设$f_{i,j,k}$表示是否能在前$i$个数中选择$j$个数使得它们和为$k$，第一维根据背包问题的常用技巧，可以在数组中去掉，变成$f_{j,k}$。然后由于只需知道是否可行，因此我们可以用$bitset$优化。

最后我们枚举$k$，然后找到一个$f_{n-1,k}=1$且$max(k,s-k)$最小的$k$（$s$为这$2n-2$个数的和）。

然后，我们考虑题目要求输出一个合法方案。

则我们用$Meet\ in\ middle$，搜索过程中记录$t,v,s$分别表示选择数的个数、选择数的和以及选择数状压后的状态。

这样一来，这道题就算做完了。

说实话，其实最后的实现是很简单的，难点主要是前面的部分。

#include<bits/stdc++.h>
#define Tp template<typename Ty>
#define Ts template<typename Ty,typename... Ar>
#define Reg register
#define RI Reg int
#define Con const
#define CI Con int&
#define I inline
#define W while
#define N 25
#define V 50000
#define LL long long
#define max(x,y) ((x)>(y)?(x):(y))
#define min(x,y) ((x)<(y)?(x):(y))
#define Gmin(x,y) (x>(y)&&(x=(y)))
using namespace std;
int n,a[2*N+5];
class DpSolver//背包
{
	private:
		bitset<2*N*V+5> f[2*N+5];
	public:
		I int GetAns()
		{
			RI i,j,s=0,ans=s;for(i=3;i<=2*n;++i) s+=a[i];//记录数的和
			for(f[0].set(0),i=3;i<=2*n;++i) for(j=min(n-1,i-2);j;--j) f[j]|=f[j-1]<<a[i];//背包
			for(i=0;i<=s;++i) f[n-1].test(i)&&max(ans,s-ans)>max(i,s-i)&&(ans=i);//统计答案
			return min(ans,s-ans);//返回
		}
}DP;
class DfsSolver//Meet in middle
{
	private:
		#define pb push_back
		LL w[N+5][N*V+5];
		I void dfs1(CI p,CI x,CI y,CI t,CI v,Con LL& s)//前一半dfs
		{
			if(x>y) return (void)(!~w[t][v]&&(w[t][v]=s));//记录答案
			dfs1(p,x+1,y,t,v,s),v+a[x]<=p&&(dfs1(p,x+1,y,t+1,v+a[x],s|(1LL<<x)),0);return;
		}
		I void dfs2(CI p,CI x,CI y,CI t,CI v,Con LL& s)//后一半dfs
		{
			if(x>y)
			{
				if(!~w[n-1-t][p-v]) return;RI i;LL g=w[n-1-t][p-v]|s;
				printf("%d ",a[1]);for(i=3;i<=2*n;++i) g>>i&1&&printf("%d ",a[i]);putchar(‘\n‘);//第一行，升序输出
				for(i=2*n;i>=3;--i) !(g>>i&1)&&printf("%d ",a[i]);printf("%d\n",a[2]);exit(0);//第二行，降序输出
			}
			dfs2(p,x+1,y,t,v,s),v+a[x]<=p&&(dfs2(p,x+1,y,t+1,v+a[x],s|(1LL<<x)),0);
		}
	public:
		I void Solve(CI x) {memset(w,-1,sizeof(w)),dfs1(x,3,n+1,0,0,0),dfs2(x,n+2,2*n,0,0,0);}
}DFS;
int main()
{
	RI i,j;for(scanf("%d",&n),i=1;i<=2*n;++i) scanf("%d",a+i);
	return sort(a+1,a+2*n+1),DFS.Solve(DP.GetAns()),0;
}

\(F\)：Swiper, no swiping!（点此看题面）

大致题意： 让你在一张图中删去若干点（不能不删，也不能删完），使得剩余的每个点度数模$3$的余数不变。

大码量多细节分类讨论题，调了两天......（话说这场比赛实在太多细节了，心态爆炸啊）

首先，这里我们按照一个点度数模$3$的余数将其分为$0$类点、$1$类点、$2$类点。（注意，下面的每一个情况都建立于之前情况不成立的基础上）

• 如果存在$0$类点：对于$n=1$的情况输出$No$，否则保留这个点。
• 如果存在一个由$2$类点组成的环：对于整张图是一个环的情况输出$No$，否则保留这个环。（注意，这个环必须是简单环，不然度数会出锅）
• 如果存在两个$1$类点：对于整张图是一条链的情况输出$No$，否则保留一条以两个$1$类点为端点、中间全为$2$类点的链。（同样要注意这些$2$类点之间不能有边，可以用$BFS$）
• 此时，由于没有$0$类点、没有超过$1$个$1$类点、没有$2$类点组成的环，所以可以保证这张图必然由一个$1$类点和一片$2$类点森林组成。可以证明，必然存在至少两棵树皆与这个$1$类点有至少两条边相连。则在两棵树上各找出一条以和$1$号点有边相连的点为端点的链，这个以$1$号点为唯一交点的两个相交的环，显然是符合要求的。但如果图中只有这样一对相交的环，也应该输出$No$。（再次强调，要注意这些$2$类点之间不能有边相连，我已经被这坑惨了）

具体实现可以看代码。

#include<bits/stdc++.h>
#define Tp template<typename Ty>
#define Ts template<typename Ty,typename... Ar>
#define Reg register
#define RI Reg int
#define Con const
#define CI Con int&
#define I inline
#define W while
#define N 500000
#define add(x,y) (e[++ee].nxt=lnk[x],e[lnk[x]=ee].to=y)
using namespace std;
int n,m,ee,x[N+5],y[N+5],s[N+5],q[N+5],lst[N+5],lnk[N+5],deg[N+5],vis[N+5],fa[N+5],tag[N+5];
struct edge {int to,nxt;}e[2*N+5];
struct data {int v;I bool operator < (Con data& o) Con {return fa[v]<fa[o.v];}}p[N+5];
class FastIO
{
	private:
		#define FS 100000
		#define tc() (A==B&&(B=(A=FI)+fread(FI,1,FS,stdin),A==B)?EOF:*A++)
		#define pc(c) (C==E&&(clear(),0),*C++=c)
		#define tn (x<<3)+(x<<1)
		#define D isdigit(c=tc())
		int T;char c,*A,*B,*C,*E,FI[FS],FO[FS],S[FS];
	public:
		I FastIO() {A=B=FI,C=FO,E=FO+FS;}
		Tp I void read(Ty& x) {x=0;W(!D);W(x=tn+(c&15),D);}
		Tp I void write(Ty x) {W(S[++T]=x%10+48,x/=10);W(T) pc(S[T--]);}
		Tp I void write(Con Ty& x,Con char& y) {write(x),pc(y);}
		I void writes(Con string& x) {for(RI i=0,y=x.length();i^y;++i) pc(x[i]);}
		I void clear() {fwrite(FO,1,C-FO,stdout),C=FO;}
}F;
I int getfa(CI x) {return fa[x]^x?fa[x]=getfa(fa[x]):x;}
I void FindLine(CI x)//有两个度数为1的点，找出一条链
{
	RI i,k,H=1,T=0;vis[q[++T]=x]=1;W(H<=T)
	{
		if(deg[k=q[H++]]%3==1&&k^x) break;
		for(i=lnk[k];i;i=e[i].nxt) !vis[e[i].to]&&(lst[q[++T]=e[i].to]=k,vis[e[i].to]=1);
	}W(s[k]=1,k^x) k=lst[k];
}
I void FindOnTree(CI x,CI st)//在以x为根的树上找出一条合法路径 
{
	RI i,k,H=1,T=0;vis[q[++T]=x]=1;W(H<=T)
	{
		if(tag[k=q[H++]]&&k^x) break;
		for(i=lnk[k];i;i=e[i].nxt) !vis[e[i].to]&&(lst[q[++T]=e[i].to]=k,vis[e[i].to]=1);
	}W(s[k]=1,k^x) k=lst[k];
}
I bool FillCircle(CI x,CI st,CI f=1)//找出以st为环上一点的简单环,f表示点数
{
	if(f>2) for(RI i=lnk[x];i;i=e[i].nxt) if(e[i].to==st) return s[x]=1;//先判断是否有环 
	vis[x]=2;for(RI i=lnk[x];i;i=e[i].nxt) if(vis[e[i].to]==1)
		if(FillCircle(e[i].to,st,f+1)) return s[x]=1;return vis[x]=1,false;
}
I bool FindCircle(CI x,CI lst)//找度数模3余2的点之间的环
{
	vis[x]=1;for(RI i=lnk[x];i;i=e[i].nxt) if(e[i].to^lst&&vis[e[i].to]) return FillCircle(x,x);//将环补充完整 
	for(RI i=lnk[x];i;i=e[i].nxt) if(e[i].to^lst&&FindCircle(e[i].to,x)) return true;return false;
}
int main()
{
	freopen("a.in","r",stdin),freopen("a.out","w",stdout);
	RI Tt,i,j,t1,t2;F.read(Tt);W(Tt--)
	{
		for(F.read(n),F.read(m),ee=0,i=1;i<=n;++i) s[i]=lnk[i]=deg[i]=vis[i]=tag[i]=0,fa[i]=i;//清空
		for(i=1;i<=m;++i) F.read(x[i]),F.read(y[i]),++deg[x[i]],++deg[y[i]];//读入边，计算点数 
		if(n==1) {F.writes("No\n");continue;}//只有一个点，无解 
		for(i=1;i<=n;++i) if(!(deg[i]%3)) {s[i]=1;goto End;}//存在度数模3余0的点，保留该点 
		for(t2=0,i=1;i<=n;++i) deg[i]==2&&++t2;if(t2==n) {F.writes("No\n");continue;}//整张图是一个环，无解 
		for(i=1;i<=m;++i) deg[x[i]]%3==2&&deg[y[i]]%3==2&&
			(fa[getfa(x[i])]=getfa(y[i]),add(x[i],y[i]),add(y[i],x[i]));//给度数模3余2的点连边
		for(i=1;i<=n;++i) if(deg[i]%3==2&&!vis[i]&&FindCircle(i,0)) goto End;//找度数模3余2的点之间的环 
		for(i=1;i<=n;++i) vis[i]=0; 
		for(t1=t2=0,i=1;i<=n;++i) deg[i]==1&&++t1,deg[i]==2&&++t2;
		if(t1==2&&t2==n-2) {F.writes("No\n");continue;}//整张图是一条链，无解
		for(t1=0,i=1;i<=n;++i) deg[i]%3==1&&++t1;if(t1>1)//有两个度数模3余1的点，找出一条链
		{
			for(i=1;i<=m;++i) ((deg[x[i]]%3)^2||(deg[y[i]]%3)^2)&&(add(x[i],y[i]),add(y[i],x[i]));//补上之前没有连的边 
			for(i=1;i<=n;++i) if(deg[i]%3==1) {FindLine(i);goto End;}//搜索出一条路径 
		} 
		for(t1=t2=0,i=1;i<=n;++i) deg[i]%3==1&&(t1=i),deg[i]==2&&++t2;
		if(deg[t1]==4&&t2==n-1) {F.writes("No\n");continue;}//整张图是两个相连的环，无解
		for(s[t1]=1,t2=0,i=1;i<=m;++i) x[i]==t1&&(tag[p[++t2].v=y[i]]=1),y[i]==t1&&(tag[p[++t2].v=x[i]]=1);//记下与度数模3余1的点相连的点 
		for(i=1;i<=n;++i) deg[i]%3==2&&(fa[i]=getfa(i)); 
		for(t1=0,sort(p+1,p+t2+1),i=1;i<t2;++i) if(fa[p[i].v]==fa[p[i+1].v])
			if(FindOnTree(p[i].v,p[i].v),!t1) {t1=1;W(i<t2&&fa[p[i].v]==fa[p[i+1].v]) ++i;}else goto End;//从两棵树中找一条合法路径 
		End:for(t1=0,i=1;i<=n;++i) !s[i]&&++t1;F.writes("Yes\n"),F.write(t1,‘\n‘);//统计删去的点数 
		for(i=1;i<=n;++i) !s[i]&&(F.write(i,‘ ‘),0);F.writes("\n");//输出删去的点 
	}return F.clear(),0;
}

【CodeForces】CodeForcesRound594 Div1 解题报告

标签：type   %s   难点   city   时间   puts   记录   认识自己   tarjan   

原文地址：https://www.cnblogs.com/chenxiaoran666/p/CodeForcesRound594Div1.html