Description

给定一张 \(n\) 个点 \(m\) 条边的无向联通图,共有 \(q\) 次操作,每次操作选择一些点作为关键点,询问有多少个点满足删去该点及与其相邻的边后,至少有两个关键点不能互相到达。\(n,q\leq 10^5,m\leq 2\cdot 10^5,\sum|S|\leq 2\cdot 10^5\)。

Sol

还是挺简单的。

就是圆方树+虚树\(\mathrm{DP}\)。

但是让我们看到了未来毒瘤的方向,出题人已经开始把树上问题放到图上了。

先把圆方树建出来,观察到两点之间的必经点就是圆方树上两点之间路径的圆点个数。

那就可以虚树\(\mathrm{DP}\)了,记录 \(dep[x]\) 表示从根到 \(x\) 有多少点是圆点,对于虚树上的每条边 \((x,y)\) 计算一下 \(dep[fa[y]]-dep[x]\) 就是这条边上圆点的贡献。然后再考虑在虚树上的点怎么计算,对于点 \(x\),如果 \(x\) 超过两个子树有关键点,或者 \(x\) 子树外还有关键点,那么 \(x\) 一定是必经点,随便判一下就好了。

然后调了一个小时的原因是倍增的 \(lg\) 数组只预处理到了 \(n\),但是建成圆方树之后深度有可能比 \(n\) 大。

Code

#pragma GCC optimize(2)
#include<bits/stdc++.h>
using namespace std;
typedef double db;
typedef long long ll;
const int N=8e5+5; int lg[N],d[N],f[N][20],ans,len;
int n,m,q,cnt,a[N],sze[N],dfn[N],low[N],head2[N];
int head[N],siz[N],dep[N],sum,stk[N],top,tot,is[N]; struct Edge{
int to,nxt;
}edge[N<<1],edge2[N<<1]; bool cmp(int x,int y){
return dfn[x]<dfn[y];
} void add(int x,int y){
edge[++cnt].to=y;
edge[cnt].nxt=head[x];
head[x]=cnt;
} void add2(int x,int y){
edge2[++cnt].to=y;
edge2[cnt].nxt=head2[x];
head2[x]=cnt;
} void tarjan(int now){
dfn[now]=low[now]=++tot;
stk[++top]=now;
for(int i=head[now];i;i=edge[i].nxt){
int to=edge[i].to;
if(!dfn[to]){
tarjan(to); low[now]=min(low[now],low[to]);
if(low[to]>=dfn[now]){
sum++; int z;
do{
z=stk[top--];
add2(sum,z),add2(z,sum);
} while(z!=to);
add2(sum,now),add2(now,sum);
}
} else low[now]=min(low[now],dfn[to]);
}
} void clear(){
cnt=tot=sum=top=0;
memset(d,0,sizeof d);
memset(f,0,sizeof f);
memset(is,0,sizeof is);
memset(dep,0,sizeof dep);
memset(dfn,0,sizeof dfn);
memset(low,0,sizeof low);
memset(stk,0,sizeof stk);
memset(sze,0,sizeof sze);
memset(head,0,sizeof head);
memset(head2,0,sizeof head2);
} void dfs(int now,int fa=0){
sze[now]=(now<=n); dfn[now]=++tot;
for(int i=head2[now];i;i=edge2[i].nxt){
int to=edge2[i].to;
if(fa==to) continue;
dep[to]=dep[now]+(to<=n);
f[to][0]=now; d[to]=d[now]+1;
for(int j=1;j<=lg[d[to]];j++) f[to][j]=f[f[to][j-1]][j-1];
dfs(to,now); sze[now]+=sze[to];
}
} int lca(int x,int y){
if(d[x]<d[y]) swap(x,y);
for(int j=lg[d[x]];~j;j--) if(d[f[x][j]]>=d[y]) x=f[x][j];
if(x==y) return x;
for(int j=lg[d[x]];~j;j--) if(f[x][j]!=f[y][j]) x=f[x][j],y=f[y][j];
return f[x][0];
} void ins(int x){
if(top<=1) return stk[++top]=x,void();
int LCA=lca(stk[top],x);
if(stk[top]==LCA) return stk[++top]=x,void();
while(top>1 and dfn[stk[top-1]]>=dfn[LCA]) add(stk[top-1],stk[top]),top--;
if(LCA!=stk[top]) add(LCA,stk[top]),stk[top]=LCA;
stk[++top]=x;
} void dfs2(int now){
siz[now]=(is[now]==q);
int flag=0;
for(int &i=head[now];i;i=edge[i].nxt){
int to=edge[i].to;
dfs2(to);
if(siz[to] and siz[to]!=len)
ans+=dep[f[to][0]]-dep[now],flag++;
siz[now]+=siz[to];
} if((siz[now]<len or flag>1) and now<=n and is[now]!=q) ans++;
} void work(){
scanf("%d",&len); ans=cnt=0;
for(int i=1;i<=len;i++)
scanf("%d",&a[i]),is[a[i]]=q;
std::sort(a+1,a+1+len,cmp);
top=0; if(is[1]!=q) stk[++top]=1;
for(int i=1;i<=len;i++) ins(a[i]);
while(top>1) add(stk[top-1],stk[top]),top--;
dfs2(1); printf("%d\n",ans);
} void solve(){
clear();
scanf("%d%d",&n,&m);sum=n;
for(int i=2;i<=n<<1;i++)
lg[i]=lg[i-1]+((1<<lg[i-1]+1)==i);
for(int x,y,i=1;i<=m;i++)
scanf("%d%d",&x,&y),add(x,y),add(y,x);
cnt=0; tarjan(1);
memset(head,0,sizeof head);
dep[1]=d[1]=1; tot=0; dfs(1);
for(scanf("%d",&q);q;work(),q--);
} signed main(){
int T;for(scanf("%d",&T);T;T--,solve());
return 0;
}

[SDOI2018] 战略游戏的更多相关文章

  1. [SDOI2018]战略游戏 圆方树,树链剖分

    [SDOI2018]战略游戏 这题是道路相遇(题解)的升级版,询问的两个点变成了\(S\)个点. LG传送门 还是先建出圆方树,考虑对于询问的\(S\)个点,答案就是圆方树上能包含这些点的最小连通块中 ...

  2. [bzoj5329] P4606 [SDOI2018]战略游戏

    P4606 [SDOI2018]战略游戏:广义圆方树 其实会了圆方树就不难,达不到黑,最多算个紫 那个转换到圆方树上以后的处理方法,画画图就能看出来,所以做图论题一定要多画图,并把图画清楚点啊!! 但 ...

  3. bzoj5315/luoguP4517 [SDOI2018]战略游戏(圆方树,虚树)

    bzoj5315/luoguP4517 [SDOI2018]战略游戏(圆方树,虚树) bzoj Luogu 题目描述略(太长了) 题解时间 切掉一个点,连通性变化. 上圆方树. $ \sum |S| ...

  4. BZOJ5329:[SDOI2018]战略游戏(圆方树,虚树)

    Description 省选临近,放飞自我的小Q无心刷题,于是怂恿小C和他一起颓废,玩起了一款战略游戏. 这款战略游戏的地图由n个城市以及m条连接这些城市的双向道路构成,并且从任意一个城市出发总能沿着 ...

  5. [BZOJ5329][SDOI2018]战略游戏

    bzoj luogu Description 省选临近,放飞自我的小Q无心刷题,于是怂恿小C和他一起颓废,玩起了一款战略游戏. 这款战略游戏的地图由n个城市以及m条连接这些城市的双向道路构成,并且从任 ...

  6. BZOJ5329: [SDOI2018]战略游戏——题解

    https://www.lydsy.com/JudgeOnline/problem.php?id=5329 https://www.luogu.org/problemnew/show/P4606 省选 ...

  7. bzoj 5329: [Sdoi2018]战略游戏

    Description 省选临近,放飞自我的小Q无心刷题,于是怂恿小C和他一起颓废,玩起了一款战略游戏. 这款战略游戏的地图由n个城市以及m条连接这些城市的双向道路构成,并且从任意一个城市出发总能沿着 ...

  8. luogu P4606 [SDOI2018]战略游戏

    LINK:战略游戏 一道很有价值的题目.这道题 一张无向联通图 每次询问给出K个关键点 问摧毁图中哪个点可以使得这K个关键的两两之间有一对不能联通 去掉的这个点不能是关键点 求方案数. 可以发现 当K ...

  9. 解题:SDOI2018 战略游戏

    题面 先圆方树然后建虚树,答案就是虚树大小.虚树没必要建出来,把原来的点的点权设为1,直接dfs序排序后相邻点求距离加上首尾两个点的距离,最后除以二(画一下可以发现是正反算了两遍),注意还要去掉询问点 ...

随机推荐

  1. Error: Unable to access xxx.jar

    在cmd中运行java -jar xxx.jar出现如下错误: Error: Unable to access xxx.jar 解决方法: 使用绝对路径:java -jar D:\Program Fi ...

  2. [LeetCode] Advantage Shuffle 优势洗牌

    Given two arrays A and B of equal size, the advantage of A with respect to B is the number of indice ...

  3. python批量提取eml附件

    从批量eml文件中提取附件,使用方式如下 代码如下 import email import os import sys #获取eml附件信息 def Get_Annex_Message(FilePat ...

  4. Shell 脚本处理用户输入

    传递参数 跟踪参数 移动变量 处理选项 将选项标准化 获得用户的输入 bash shell提供了一些不同的方法来从用户处获取数据,包括命令行参数(添加在命令后数据),命令行选项(可以修改命令行为的单个 ...

  5. js 阻止事件执行

    三种阻止事件执行的方式 event.preventDefault() event.stopPropagation() return false event.preventDefault() 阻止特定事 ...

  6. 接口自动化集成到jenkins(Java+testng+maven+git)

    一jenkins启动命令:jenkins 查看端口号: 1.lsof -i:端口号 2.netstat -tunlp|grep 端口号 二: 登录:http://localhost:8080 输入:u ...

  7. 别以为真懂Openstack: 虚拟机创建的50个步骤和100个知识点(5)

    八.KVM 这一步,像virsh start命令一样,将虚拟机启动起来了.虚拟机启动之后,还有很多的步骤需要完成. 步骤38:从DHCP Server获取IP 有时候往往数据库里面,VM已经有了IP, ...

  8. Spring IOC容器基本原理

    2.2.1 IOC容器的概念IOC容器就是具有依赖注入功能的容器,IOC容器负责实例化.定位.配置应用程序中的对象及建立这些对象间的依赖.应用程序无需直接在代码中new相关的对象,应用程序由IOC容器 ...

  9. springboot加ES实现全局检索

    ElasticSearch是一个基于Lucene的搜索服务器.它提供了一个分布式多用户能力的全文搜索引擎,基于RESTful web接口.Elasticsearch是用Java开发的,并作为Apach ...

  10. Java线程状态Jstack线程状态BLOCKED/TIMED_WAITING/WAITING解释

    一.线程5种状态 新建状态(New) 新创建了一个线程对象. 就绪状态(Runnable) 线程对象创建后,其他线程调用了该对象的start()方法.该状态的线程位于可运行线程池中,变得可运行,等待获 ...