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

题目链接：

　　传送~~

题解：

　　  老夫实在是码不动了……

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

　　（调死人啦！

代码：

　

#define Troy 10/19/2017

#include <bits/stdc++.h>

using namespace std;

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

const int N=1e5+8;

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

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

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<<2],*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]=1;
    for(edges *i=head[x];i;i=i->last)if(i->v!=fa){
        deep[i->v]=deep[x]+1;
        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=1;i<=m;i++)
        query[i].in();
    sort(query+1,query+1+m,cmpx);
    int t=1e6;
    while(1){
        int c=read(),a,b;
        if(c==-1)    break;
        a=read(),b=read();
        if(a>b)    swap(a,b);
        if(c==0){
            int x=upper_bound(query+1,query+1+m,(Q){a,b,0,0},cmpx)-query-1;
            query[x].times=t;
        }else{
            q++;
            query[q+m]=(Q){a,b,t,1};
        }
        t--;
    }
    sort(query+1,query+1+q+m,cmpy);
    for(int i=1;i<=m+q&&query[i].times==0;i++)
        push(query[i].u,query[i].v),
        push(query[i].v,query[i].u);
    tarjan(1,0);
    memset(head,0,sizeof(head));cnt=0;
    for(int i=1;i<=m+q&&query[i].times==0;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(1,1);    
    idx=0;
    dfs(1,1,1);
}

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

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

inline void build(Tree *&u,int l,int r){
    u=tree+t_cnt;t_cnt++;
    u->val=0;
    if(l==r){
        u->son[0]=u->son[1]=NULL;
        u->val=(l!=1);
        return;
    }
    int mid=l+r>>1;
    build(u->son[0],l,mid);
    build(u->son[1],mid+1,r);
    for(int i=0;i<2;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==0){    
        u->val=0;
        return;
    }
    int mid=l+r>>1;
    if(y>mid)
        change(u->son[1],mid+1,r,x,y);
    if(x<=mid)
        change(u->son[0],l,mid,x,y);
    u->val=0;
    for(int i=0;i<2;i++)
        u->val+=u->son[i]->val;
}

inline int sum(Tree *u,int l,int r,int x,int y){
    if(u->val==0)    return 0;    
    if(x<=l&&r<=y)
        return u->val;
    int mid=l+r>>1;
    if(x>mid)
        return sum(u->son[1],mid+1,r,x,y);
    else    if(y<=mid)
        return sum(u->son[0],l,mid,x,y);
    else    return sum(u->son[0],l,mid,x,y)+sum(u->son[1],mid+1,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,1,idx,tid[g[x]],tid[x]);        
        x=f[g[x]];
    }
    if(x==y)    return;
    if(deep[x]>deep[y])
        swap(x,y);
    change(root,1,idx,tid[x]+1,tid[y]);
}

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

inline void work(){
    build(root,1,idx);
    int t=q;
    for(int i=1;i<=m+q;i++)
        if(query[i].times==0)
            continue;
        else{
            if(query[i].val==0){
                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=1;i<=q;i++)
        printf("%d\n",ans[i]);
}

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