【BZOJ 1969】 1969: [Ahoi2005]LANE 航线规划 （树链剖分+线段树）

1969: [Ahoi2005]LANE 航线规划

Description

对Samuel星球的探险已经取得了非常巨大的成就，于是科学家们将目光投向了Samuel星球所在的星系——一个巨大的由千百万星球构成的Samuel星系。 星际空间站的Samuel II巨型计算机经过长期探测，已经锁定了Samuel星系中许多星球的空间坐标，并对这些星球从1开始编号1、2、3……。 一些先遣飞船已经出发，在星球之间开辟探险航线。 探险航线是双向的，例如从1号星球到3号星球开辟探险航线，那么从3号星球到1号星球也可以使用这条航线。 例如下图所示：  在5个星球之间，有5条探险航线。 A、B两星球之间，如果某条航线不存在，就无法从A星球抵达B星球，我们则称这条航线为关键航线。 显然上图中，1号与5号星球之间的关键航线有1条：即为4-5航线。 然而，在宇宙中一些未知的磁暴和行星的冲撞，使得已有的某些航线被破坏，随着越来越多的航线被破坏，探险飞船又不能及时回复这些航线，可见两个星球之间的关键航线会越来越多。 假设在上图中，航线4-2（从4号星球到2号星球）被破坏。此时，1号与5号星球之间的关键航线就有3条：1-3，3-4，4-5。 小联的任务是，不断关注航线被破坏的情况，并随时给出两个星球之间的关键航线数目。现在请你帮助完成。

Input

第一行有两个整数N，M。表示有N个星球（1< N < 30000），初始时已经有M条航线（1 < M < 100000）。随后有M行，每行有两个不相同的整数A、B表示在星球A与B之间存在一条航线。接下来每行有三个整数C、A、B。C为1表示询问当前星球A和星球B之间有多少条关键航线；C为0表示在星球A和星球B之间的航线被破坏，当后面再遇到C为1的情况时，表示询问航线被破坏后，关键路径的情况，且航线破坏后不可恢复； C为-1表示输入文件结束，这时该行没有A,B的值。被破坏的航线数目与询问的次数总和不超过40000。

Output

对每个C为1的询问，输出一行一个整数表示关键航线数目。 注意：我们保证无论航线如何被破坏，任意时刻任意两个星球都能够相互到达。在整个数据中，任意两个星球之间最多只可能存在一条直接的航线。

Sample Input

5 5
1 2
1 3
3 4
4 5
4 2
1 1 5
0 4 2
1 5 1
-1

Sample Output

1
3

HINT

Source

【分析】

　　hh想出来了。。

　　删边不好做，考虑加边，题目保证删完边还是联通的，我们维护一棵树（假设是一棵树）

　　假设现在把x，y连起来，假设他们的LCA为z，显然可以把x->y路径上的点全部缩成一个点，加边后这条路径上的边成环，所以之后一定不是关键边。

　　事实上呢，不用缩点，直接把两个点的路径的边权清0，即z->x,z->y路径的边清零。

　　没有清0的边边权为1，询问就是问x->y路径的边权和。

　　用树剖和线段树维护就好了。

　　【预处理别人都是MAP什么的，表示不会= =就排了个序搞搞了。。

 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 using namespace std;
 #define Maxn 30010
 #define Maxm 100010
 
 struct node
 {
     int x,y,next;
     int bj,id;
 }t[Maxn*],tt[Maxm*];
 int first[Maxn],len;
 
 void ins(int x,int y)
 {
     // printf("%d -> %d\n",x,y);
     t[++len].x=x;t[len].y=y;
     t[len].next=first[x];first[x]=len;
 }
 
 struct nnode
 {
     int l,r,lc,rc,sm;
 }tr[Maxn*];
 
 void upd(int x)
 {
     if(tr[x].l==tr[x].r||tr[x].sm!=) return;
     int lc=tr[x].lc,rc=tr[x].rc;
     tr[lc].sm=tr[rc].sm=;
 }
 
 int tot;
 int build(int l,int r)
 {
     int x=++tot;
     tr[x].l=l;tr[x].r=r;
     if(l!=r)
     {
         int mid=(l+r)>>;
         tr[x].lc=build(l,mid);
         tr[x].rc=build(mid+,r);
     }
     else tr[x].lc=tr[x].rc=;
     tr[x].sm=r-l+;
     return x;
 }
 
 void change(int x,int l,int r)
 {
     if(tr[x].l==l&&tr[x].r==r)
     {
         tr[x].sm=;
         return;
     }
     upd(x);
     int mid=(tr[x].l+tr[x].r)>>,lc=tr[x].lc,rc=tr[x].rc;
     if(r<=mid) change(lc,l,r);
     else if(l>mid) change(rc,l,r);
     else
     {
         change(lc,l,mid);
         change(rc,mid+,r);
     }
     tr[x].sm=tr[lc].sm+tr[rc].sm;
 }
 
 int query(int x,int l,int r)
 {
     if(tr[x].sm==) return ;
     if(tr[x].l==l&&tr[x].r==r) return tr[x].sm;
     upd(x);
     int mid=(tr[x].l+tr[x].r)>>,lc=tr[x].lc,rc=tr[x].rc;
     if(r<=mid) return query(lc,l,r);
     else if(l>mid) return query(rc,l,r);
     else return query(lc,l,mid)+query(rc,mid+,r);
 }
 
 int tp[Maxn],sum[Maxn],son[Maxn],dfn[Maxn],dep[Maxn];
 int ff[Maxn];
 int cnt;
 void dfs(int x,int f)
 {
     son[x]=;sum[x]=;dep[x]=dep[f]+;
     ff[x]=f;
     for(int i=first[x];i;i=t[i].next) if(t[i].y!=f)
     {
         int y=t[i].y;
         dfs(y,x);
         sum[x]+=sum[y];
         if(son[x]==||sum[son[x]]<sum[y]) son[x]=y;
     }
 }
 
 void dfs2(int x,int tpp)
 {
     dfn[x]=++cnt;tp[x]=tpp;
     if(son[x]) dfs2(son[x],tpp);
     for(int i=first[x];i;i=t[i].next) if(t[i].y!=ff[x]&&t[i].y!=son[x])
     {
         int y=t[i].y;
         dfs2(y,y);
     }
 }
 
 void fchange(int x,int y)
 {
     while(tp[x]!=tp[y])
     {
         if(dep[tp[x]]<dep[tp[y]]) swap(x,y);
         change(,dfn[tp[x]],dfn[x]);
         x=ff[tp[x]];
     }
     if(dep[x]<dep[y]) swap(x,y);
     if(x!=y) change(,dfn[y]+,dfn[x]);
 }
 
 int fquery(int x,int y)
 {
     int ans=;
     while(tp[x]!=tp[y])
     {
         if(dep[tp[x]]<dep[tp[y]]) swap(x,y);
         ans+=query(,dfn[tp[x]],dfn[x]);
         x=ff[tp[x]];
     }
     if(dep[x]<dep[y]) swap(x,y);
     if(x!=y)
     {
         // if(dfn[y]+1>dfn[x]) while(1);
         ans+=query(,dfn[y]+,dfn[x]);
     }
     return ans;
 }
 
 int fa[Maxn];
 int ffa(int x)
 {
     if(fa[x]!=x) fa[x]=ffa(fa[x]);
     return fa[x];
 }
 
 bool cmp(node x,node y)
 {
     if(x.x==y.x&&x.y==y.y) return x.bj<y.bj;
     return (x.x==y.x)?(x.y<y.y):(x.x<y.x);
 }
 bool cmp2(node x,node y) {return x.id<y.id;}
 
 int ans[Maxn];
 
 void solve()
 {
     int n,m;
     scanf("%d%d",&n,&m);
     int ll=;
     for(int i=;i<=m;i++)
     {
         int x,y;
         ll++;
         scanf("%d%d",&tt[ll].x,&tt[ll].y);
         tt[ll].bj=;//cha ru
     }
     int ct=;
     while()
     {
         int cs=;
         scanf("%d",&cs);
         if(cs==-) break;
         ll++;
         scanf("%d%d",&tt[ll].x,&tt[ll].y);
         if(cs==) tt[ll].bj=-;//shan chu
         else tt[ll].bj=;//xun wen
         tt[ll].id=++ct;
     }
     sort(tt+,tt++ll,cmp);
     for(int i=;i<=n;i++) fa[i]=i;
     ct++;
     int pp=;
     for(int i=;i<=ll;i++)
     {
         if(tt[i].bj==) continue;
         if(tt[i].bj==)
         {
             if(pp==||tt[i].x!=tt[pp].x||tt[i].y!=tt[pp].y)
             {
                 if(ffa(tt[i].x)==ffa(tt[i].y))
                 {
                     tt[i].bj=-;
                     tt[i].id=ct;
                 }
                 else
                 {
                     ins(tt[i].x,tt[i].y);
                     ins(tt[i].y,tt[i].x);
                     fa[ffa(tt[i].x)]=tt[i].y;
                 }
             }
         }
         pp=i;
     }
     dep[]=;
     dfs(,);cnt=;
     dfs2(,);
     build(,n);
     sort(tt+,tt++ll,cmp2);
     // return ;
     ans[]=;
     for(int i=ll;i>=;i--)
     {
         if(tt[i].bj==) continue;
         if(tt[i].bj==-)
         {
             fchange(tt[i].x,tt[i].y);
         }
         else
         {
             ans[++ans[]]=fquery(tt[i].x,tt[i].y);
         }
     }
     for(int i=ans[];i>=;i--) printf("%d\n",ans[i]);
 }
 
 int main()
 {
     solve();
     return ;
 }

2017-03-06 14:04:26