[bzoj5329] P4606 [SDOI2018]战略游戏

P4606 [SDOI2018]战略游戏：广义圆方树

其实会了圆方树就不难，达不到黑，最多算个紫

那个转换到圆方树上以后的处理方法，画画图就能看出来，所以做图论题一定要多画图，并把图画清楚点啊！！

但我怎么从9点一直调到下午4点啊啊啊啊啊

双倍经验：P4320 道路相遇，但是被卡常了并没有过

给出一个无向图，和 \(q\) 个询问，每次给出 \(s\) 个点，问存在几个点，使得这个点和他相连的边被去除后，这 \(s\) 个点中，至少存在一对点互不相通

---

先用 tarjan 对原图建立圆方树，然后可以枚举每两对给定的点，求他们的树上路径中，有几个非叶子节点的圆点（根据圆方树的性质，这就是他们之间的割点，也就是满足题目要求的点）

这些点的并集的大小即为答案

但这样复杂度显然过不去，而且这样描述答案不方便做转化（一开始我就是一直在这样想，导致卡了好长时间）

所以应该给出另一种对答案的描述：在圆方树中，包含所有给出的点的联通块，最小的大小，再减去 \(s\) 即为答案

显然这和刚才那样是等价的

但是还是不会算

发现题目中给出的 \(s\) 个点是排好序的，然而这并没有什么用，但这启示我们，不妨把给出的点按照他们在圆方树中的 dfs 序重新排序

然后画一个图，发现，如果由 dfs 序从小到大，以此走过所有的点，然后再从第 \(s\) 个点走回第 \(1\) 个点

在走过路径中，如果不考虑每相邻两个点的 LCA（此时我们走的是树上最短路径，显然会经过 LCA，这里说的不考虑就是不把它计入在内），每个点恰好被走了两次，而这些被走过的点恰好就是我们要求的联通块

其实这里本来是有个图的，但画的太丑就没加进来，自己画一画吧

所以我们只要为每个点赋值一个点权，方点为 \(0\) 圆点为 \(1\)，倍增求树上路径点权和就好了

当然，最后还要再除以二，再减去 \(s\)

不过这样会有一个问题，就是第一个点和第 \(s\) 个点的 LCA 会不被统计，所以如果这个点是个圆点答案就再加一

代码

#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cmath>
#include<map>
#include<iomanip>
#include<cstring>
#define reg register
#define EN std::puts("")
#define LL long long
inline int read(){
	register int x=0;register int y=1;
	register char c=std::getchar();
	while(c<'0'||c>'9'){if(c=='-') y=0;c=std::getchar();}
	while(c>='0'&&c<='9'){x=x*10+(c^48);c=std::getchar();}
	return y?x:-x;
}
#define N 400007
#define M 400006
struct graph{
	int tot;
	int fir[N],nex[M],to[M];
	inline void add(int u,int v){
		to[++tot]=v;
		nex[tot]=fir[u];fir[u]=tot;
	}
	inline void clear(){
		std::memset(fir,0,sizeof fir);std::memset(to,0,sizeof to);
		std::memset(nex,0,sizeof nex);tot=0;
	}
}T,G;
int n,m;
int dfn[N],deep[N],size[N],dfscnt;
int fa[22][N],val[N],S[N];
inline int cmp(int x,int y){return dfn[x]<dfn[y];}
struct get_bcc{
	int dfn[N],low[N],stack[N],top;
	int bcccnt,dfscnt;
	void tarjan(int u){
		dfn[u]=low[u]=++dfscnt;stack[top++]=u;
		for(reg int v,i=G.fir[u];i;i=G.nex[i]){
			v=G.to[i];
			if(!dfn[v]){
				tarjan(v);
				low[u]=std::min(low[u],low[v]);
				if(low[v]>=dfn[u]){
					bcccnt++;
					do{
						T.add(bcccnt,stack[--top]);T.add(stack[top],bcccnt);
					}while(stack[top]^v);
					T.add(bcccnt,u);T.add(u,bcccnt);
				}
			}
			else low[u]=std::min(low[u],dfn[v]);
		}
	}
}BCC;
inline void clear(){
	T.clear();G.clear();
	std::memset(BCC.dfn,0,sizeof BCC.dfn);std::memset(BCC.low,0,sizeof BCC.low);
	BCC.top=0;BCC.dfscnt=0;
	dfscnt=0;
	std::memset(dfn,0,sizeof dfn);
	std::memset(fa,0,sizeof fa);std::memset(val,0,sizeof val);
	std::memset(deep,0,sizeof deep);std::memset(size,0,sizeof size);
}
void dfs(int u,int fat){
	size[u]=1;deep[u]=deep[fat]+1;
	dfn[u]=++dfscnt;fa[0][u]=fat;
	val[u]=val[fat]+(u<=n);
	for(reg int v,i=T.fir[u];i;i=T.nex[i]){
		v=T.to[i];
		if(v==fat) continue;
		dfs(v,u);size[u]+=size[v];
	}
}
inline void pre(){
	for(reg int i=1;i<=20;i++){
		for(reg int j=1;j<=BCC.bcccnt;j++) fa[i][j]=fa[i-1][fa[i-1][j]];
	}
}
inline int get(int x,int y){
	if(deep[x]<deep[y]) std::swap(x,y);
	for(reg int i=20;~i;i--)
		if(deep[fa[i][x]]>=deep[y])x=fa[i][x];
	if(x==y) return x;
	for(reg int i=20;~i;i--)
		if(fa[i][x]!=fa[i][y]) x=fa[i][x],y=fa[i][y];
	return fa[0][x];
}
int main(){int cases=read();while(cases--){
	BCC.bcccnt=n=read();m=read();
	for(reg int u,v,i=1;i<=m;i++){
		u=read();v=read();
		G.add(u,v);G.add(v,u);
	}
	BCC.tarjan(1);
	dfs(1,0);
	pre();
//
//		EN;EN;
//		std::printf("n : %d  m : %d  bcccnt : %d\n",n,m,BCC.bcccnt);
//		for(reg int i=1;i<=BCC.bcccnt;i++){
//			std::printf("now : %d  size : %d  deep : %d  dfn : %d  val : %d\n",i,size[i],deep[i],dfn[i],val[0][i]);
//			for(reg int j=T.fir[i];j;j=T.nex[j]) std::printf("%d ",T.to[j]);
//			EN;
//		}
//
	reg int s,ans,lca;
	int q=read();while(q--){
 		s=read();ans=0;
		for(reg int i=1;i<=s;i++) S[i]=read();
		std::sort(S+1,S+1+s,cmp);S[s+1]=S[1];
		for(reg int i=1;i<=s;i++){
			lca=get(S[i],S[i+1]);
			ans+=val[S[i]]+val[S[i+1]]-val[lca]*2;
		}
		ans>>=1;ans-=s;
		ans+=(get(S[1],S[s])<=n);
		std::printf("%d\n",ans);
	}
	if(cases) clear();
}
	return 0;
}