【BZOJ】1969: [Ahoi2005]LANE 航线规划

题目链接：

　　传送~~

题解：

　　  老夫实在是码不动了……

　　正着搞显然不好做，尝试倒着乱搞。先给被删除的边标记一个时间戳，先删除的时间戳大，同时维护询问时间戳，询问早的时间戳大。没被删除过的边时间戳都是0。然后瞎tarjan一次，建立双联通分量树。然后考虑每条被删除的边补会图中，相当于把两点所属双联通分量之间路径边权变为0。然后强行树剖一波即可。

　　（调死人啦！

代码：

　

 #define Troy 10/19/2017

 #include <bits/stdc++.h>

 using namespace std;

 inline int read(){
     int s=,k=;char ch=getchar();
     while(ch<''|ch>'')    ch=='-'?k=-:,ch=getchar();
     while(ch>&ch<='')    s=s*+(ch^),ch=getchar();
     return s*k;
 }

 const int N=1e5+;

 int n,m,q,ans[N];

 struct Q{
     int u,v,times,val;
     inline void in(){
         u=read(),v=read(),val=;
         if(u>v)    swap(u,v);
     }
 }query[N<<];

 inline bool cmpx(Q a,Q b){
     return a.u!=b.u?a.u<b.u:a.v<b.v;
 }

 inline bool cmpy(Q a,Q b){
     return a.times<b.times;
 }

 struct edges{
     int v;edges *last;
 }edge[N<<],*head[N];int cnt;

 inline void push(int u,int v){
     edge[++cnt]=(edges){v,head[u]};head[u]=edge+cnt;
 }

 /**********************************************************************/

 int dfn[N],low[N],bccno[N],idx,stk[N],top,bcc_cnt;

 inline void tarjan(int x,int fa){
     dfn[x]=low[x]=++idx;
     stk[++top]=x;
     for(edges *i=head[x];i;i=i->last)    if(i->v!=fa){
         if(!dfn[i->v]){
             tarjan(i->v,x);
             low[x]=min(low[x],low[i->v]);
         }else
             low[x]=min(low[x],dfn[i->v]);
     }
     if(dfn[fa]<low[x]){
         bcc_cnt++;int t;
         do{
             t=stk[top--];
             bccno[t]=bcc_cnt;
         }while(t!=x);
     }
 }

 /*****************************************************************/
 int size[N],heavy[N],deep[N],g[N],f[N],tid[N];

 inline void dfs(int x,int fa){
     size[x]=;
     for(edges *i=head[x];i;i=i->last)if(i->v!=fa){
         deep[i->v]=deep[x]+;
         f[i->v]=x;
         dfs(i->v,x);
         size[x]+=size[i->v];
         if(size[i->v]>size[heavy[x]])
             heavy[x]=i->v;
     }
 }

 inline void dfs(int x,int fa,int grand){
     tid[x]=++idx;
     g[x]=grand;
     if(heavy[x])
         dfs(heavy[x],x,grand);
     for(edges *i=head[x];i;i=i->last)
         if(i->v!=fa&&i->v!=heavy[x])
             dfs(i->v,x,i->v);
 }

 inline void init(){
     n=read(),m=read();
     for(int i=;i<=m;i++)
         query[i].in();
     sort(query+,query++m,cmpx);
     int t=1e6;
     while(){
         int c=read(),a,b;
         if(c==-)    break;
         a=read(),b=read();
         if(a>b)    swap(a,b);
         if(c==){
             int x=upper_bound(query+,query++m,(Q){a,b,,},cmpx)-query-;
             query[x].times=t;
         }else{
             q++;
             query[q+m]=(Q){a,b,t,};
         }
         t--;
     }
     sort(query+,query++q+m,cmpy);
     for(int i=;i<=m+q&&query[i].times==;i++)
         push(query[i].u,query[i].v),
         push(query[i].v,query[i].u);
     tarjan(,);
     memset(head,,sizeof(head));cnt=;
     for(int i=;i<=m+q&&query[i].times==;i++)
         if(bccno[query[i].u]!=bccno[query[i].v])
             push(bccno[query[i].u],bccno[query[i].v]),
             push(bccno[query[i].v],bccno[query[i].u]);
     dfs(,);
     idx=;
     dfs(,,);
 }

 /********************************************************************/

 struct Tree{
     Tree *son[];
     int val;
 }*root,tree[N<<];int t_cnt;

 inline void build(Tree *&u,int l,int r){
     u=tree+t_cnt;t_cnt++;
     u->val=;
     if(l==r){
         u->son[]=u->son[]=NULL;
         u->val=(l!=);
         return;
     }
     int mid=l+r>>;
     build(u->son[],l,mid);
     build(u->son[],mid+,r);
     for(int i=;i<;i++)
         u->val+=u->son[i]->val;
 }

 inline void change(Tree *u,int l,int r,int x,int y){
     if((x<=l&&r<=y)||u->val==){
         u->val=;
         return;
     }
     int mid=l+r>>;
     if(y>mid)
         change(u->son[],mid+,r,x,y);
     if(x<=mid)
         change(u->son[],l,mid,x,y);
     u->val=;
     for(int i=;i<;i++)
         u->val+=u->son[i]->val;
 }

 inline int sum(Tree *u,int l,int r,int x,int y){
     if(u->val==)    return ;
     if(x<=l&&r<=y)
         return u->val;
     int mid=l+r>>;
     if(x>mid)
         return sum(u->son[],mid+,r,x,y);
     else    if(y<=mid)
         return sum(u->son[],l,mid,x,y);
     else    return sum(u->son[],l,mid,x,y)+sum(u->son[],mid+,r,x,y);
 }

 inline void change(int x,int y){
     while(g[x]!=g[y]){
         if(deep[g[x]]<deep[g[y]])
             swap(x,y);
         change(root,,idx,tid[g[x]],tid[x]);
         x=f[g[x]];
     }
     if(x==y)    return;
     if(deep[x]>deep[y])
         swap(x,y);
     change(root,,idx,tid[x]+,tid[y]);
 }

 inline int sum(int x,int y){
     int ret=;
     while(g[x]!=g[y]){
         if(deep[g[x]]<deep[g[y]])
             swap(x,y);
         ret+=sum(root,,idx,tid[g[x]],tid[x]);
         x=f[g[x]];
     }
     if(x!=y){
         if(deep[x]>deep[y])
             swap(x,y);
         ret+=sum(root,,idx,tid[x]+,tid[y]);
     }
     return ret;
 }

 inline void work(){
     build(root,,idx);
     int t=q;
     for(int i=;i<=m+q;i++)
         if(query[i].times==)
             continue;
         else{
             if(query[i].val==){
                 change(bccno[query[i].u],bccno[query[i].v]);
             }
             else{
                 ans[t]=sum(bccno[query[i].u],bccno[query[i].v]);
                 t--;
             }
         }
     for(int i=;i<=q;i++)
         printf("%d\n",ans[i]);
 }

 int main(){
     init();
     work();
 }