题目链接
题目大意：给你一个n个点m条边的图，一共有q次操作，每次给x和y两点间加一条边，问每次操作完后图中有几条割边。
分析：很明显是要求割边的数量，但是不同的是这次是给q次操作，每次操作完用tarjan算法明显不现实，所以我们考虑有没有某种数据结构去优化这个过程。考虑缩点，割边即为缩点后树上的一条边，那么我们考虑给边赋值，每次询问就求缩点图上两点间权值之和，可以用树链剖分去实现这个过程。我们用ans表示整个图上割边数量，每次用ans-ask（x，y），输出即是答案。
注意点：边双连通缩点注意平行边的处理，树链剖分注意边权下放给点，求lca的过程中注意lca的权值不要，缩点后建图时要用新的编号。
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<map>
#include<vector>
#define lk (k<<1)
#define rk (k<<1|1)
using namespace std;
typedef long long ll;
const double eps=1e-8;
const double pi=acos(-1.0);
const int inf=0x3f3f3f3f;
const int N=1e5+10,M=2e5+10;
int n,m;
struct edge
{
int u,v,next;
}e[M<<1];
int head[N],cnt;
void add(int u,int v)
{
e[++cnt].v=v;
e[cnt].next=head[u];
e[cnt].u=u;
head[u]=cnt;
}
int dfn[N],low[N],len;
int bcc[N],bcc_cnt;
int st[N],Top;
void dfs(int u,int p)
{
dfn[u]=low[u]=++len;
st[++Top]=u;
bool pd=false;
for(int i=head[u];i;i=e[i].next)
{
int v=e[i].v;
if(v==p&&!pd)
{
pd=true;
continue;
}
if(!dfn[v])
{
dfs(v,u);
low[u]=min(low[u],low[v]);
}
else if(dfn[v])
{
low[u]=min(low[u],dfn[v]);
}
}
if(dfn[u]==low[u])
{
bcc_cnt++;
while(1)
{
int now=st[Top--];
bcc[now]=bcc_cnt;
if(now==u) break;
}
}
}
int ans;
void tarjan()
{
bcc_cnt=len=0;
for(int i=1;i<=n;i++) if(!dfn[i]) dfs(i,0);
cnt=0;
memset(head,0,sizeof(head));
for(int i=1;i<=2*m;i+=2)
{
int u=e[i].u;
int v=e[i].v;
if(bcc[u]!=bcc[v]){
add(bcc[u],bcc[v]);
add(bcc[v],bcc[u]);
ans++;
}
}
}
int size[N],dep[N],fa[N],son[N];
int top[N],id[N],w[N];
void dfs1(int u,int p)
{
dep[u]=dep[p]+1;
fa[u]=p;
son[u]=0;
size[u]=1;
for(int i=head[u];i;i=e[i].next)
{
int v=e[i].v;
if(v==p) continue;
w[v]=1;
dfs1(v,u);
size[u]+=size[v];
if(size[v]>size[son[u]]) son[u]=v;
}
}
void dfs2(int u,int p)
{
dfn[u]=++len;
id[len]=u;
if(son[u])
{
top[son[u]]=top[u];
dfs2(son[u],u);
}
for(int i=head[u];i;i=e[i].next)
{
int v=e[i].v;
if(v==p) continue;
if(!top[v])
{
top[v]=v;
dfs2(v,u);
}
}
}
struct node
{
int l,r;
int sum,lazy;
}t[N<<2];
void pushdown(int k)
{
if(t[k].lazy)
{
t[lk].lazy=t[rk].lazy=1;
t[lk].sum=t[rk].sum=0;
t[k].lazy=0;
}
}
void pushup(int k)
{
t[k].sum=t[lk].sum+t[rk].sum;
}
void build(int k,int l,int r)
{
t[k].l=l;
t[k].r=r;
t[k].sum=0;
t[k].lazy=0;
if(l==r)
{
t[k].sum=w[id[l]];
return;
}
int mid=(l+r)>>1;
build(lk,l,mid);
build(rk,mid+1,r);
pushup(k);
}
void update(int k,int l,int r)
{
if(t[k].l>=l&&t[k].r<=r)
{
t[k].lazy=1;
t[k].sum=0;
}
else
{
pushdown(k);
int mid=(t[k].l+t[k].r)>>1;
if(l<=mid) update(lk,l,r);
if(r>mid) update(rk,l,r);
pushup(k);
}
}
int query(int k,int l,int r)
{
if(t[k].l>=l&&t[k].r<=r)
{
return t[k].sum;
}
else
{
pushdown(k);
int mid=(t[k].l+t[k].r)>>1;
int sum=0;
if(l<=mid) sum+=query(lk,l,r);
if(r>mid) sum+=query(rk,l,r);
return sum;
}
}
int ask(int u,int v)
{
int fu=top[u],fv=top[v];
int sum=0;
while(fu!=fv)
{
if(dep[fu]<dep[fv]) swap(fu,fv),swap(u,v);
sum+=query(1,dfn[fu],dfn[u]);
update(1,dfn[fu],dfn[u]);
u=fa[fu];fu=top[u];
}
if(dep[u]>dep[v]) swap(u,v);
if(u==v) return sum;
sum+=query(1,dfn[u]+1,dfn[v]);
update(1,dfn[u]+1,dfn[v]);
return sum;
}
int main()
{
int tt=0;
while(scanf("%d%d",&n,&m)==2)
{
if(n==0&&m==0) break;
ans=0;
cnt=0;
memset(head,0,sizeof(head));
memset(low,0,sizeof(low));
memset(bcc,0,sizeof(bcc));
memset(top,0,sizeof(top));
memset(dep,0,sizeof(dep));
memset(size,0,sizeof(size));
memset(fa,0,sizeof(fa));
memset(son,0,sizeof(son));
memset(dfn,0,sizeof(dfn));
for(int i=1;i<=m;i++){
int u,v;
scanf("%d%d",&u,&v);
add(u,v);
add(v,u);
}
tarjan();
len=0;
memset(dfn,0,sizeof(dfn));
dfs1(bcc[1],0);
top[bcc[1]]=bcc[1];
dfs2(bcc[1],0);
build(1,1,len);
int q;
scanf("%d",&q);
printf("Case %d:\n",++tt);
while(q--)
{
int x,y;
scanf("%d%d",&x,&y);
int val=ask(bcc[x],bcc[y]);
ans-=val;
printf("%d\n",ans);
}
printf("\n");
}
return 0;
}