BZOJ 1969 树链剖分+Tarjan缩点

发现自己Tarjan的板子有错误.发现可以用Map直接删去边，Get.

听说std是双连通、LCA、并查集、离线思想、用BIT维护dfs序和并查集维护LCA的动态缩点的好题

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <stack>
#define mp make_pair
#define pa pair<int,int>
#define pb push_back
#define fi first
#define se second
using namespace std;
inline void Get_Int(int &x)
{
    x=0;  char ch=getchar(); int f=1;
    while (ch<'0' || ch>'9') {if (ch=='-') f=-1; ch=getchar();}
    while (ch>='0' && ch<='9') {x=x*10+ch-'0'; ch=getchar();} x*=f;
}
inline void Put_Int(int x)
{
    char ch[20]; int top=0;
    if (x==0) ch[++top]='0';
    while (x) ch[++top]=x%10+'0',x/=10;
    while (top) putchar(ch[top--]); putchar('
');
}
//===================================================
const int Maxm=200100;
const int Maxn=30100;
const int Maxop=40100;
struct EDGE{int to,next;}edge[Maxm];
struct OP{int type,u,v;}Op[Maxop];
int head[Maxn],siz[Maxn],father[Maxn],top[Maxn],dep[Maxn],num[Maxn],sum[Maxn<<2],clr[Maxn<<2];
int Belong[Maxn],Low[Maxn],Dfn[Maxn],Ans[Maxn];
int Stack[Maxn];
int stamp,Stamp,cnt,scc,apex,Q,n,m,u,v;
bool vis[Maxn];
map<pa,bool> Edge;
vector<pa> V;
set <pa> S;
inline void Add(int u,int v) 
{edge[cnt].to=v;edge[cnt].next=head[u];head[u]=cnt++;}
inline int Max(int x,int y) {return x>y?x:y;}
inline int Min(int x,int y) {return x>y?y:x;}
inline void Build_G()
{
    map<pa,bool>::iterator it;
    for (it=Edge.begin();it!=Edge.end();it++)
        if (it->se) 
            Add(it->fi.fi,it->fi.se);
}
inline void Clear_G()
{    
    map<pa,bool>::iterator it;
    for (it=Edge.begin();it!=Edge.end();it++)
        if (it->se) it->se=false;
}
//=================================================

void Dfs1(int u)
{
    vis[u]=true; siz[u]=1;
    for (int i=head[u];i!=-1;i=edge[i].next)
        if (!vis[edge[i].to]) 
        {
            father[edge[i].to]=u;
            dep[edge[i].to]=dep[u]+1;
            Dfs1(edge[i].to);
            siz[u]+=siz[edge[i].to];
        }
}
void Dfs2(int u,int chain)
{
    num[u]=++stamp; top[u]=chain; vis[u]=true; int k=0;
    for (int i=head[u];i!=-1;i=edge[i].next)
        if (!vis[edge[i].to] && (siz[edge[i].to]>siz[k] || k==0)) k=edge[i].to;
    if (k==0) return;
    Dfs2(k,chain);
    for (int i=head[u];i!=-1;i=edge[i].next)
        if (!vis[edge[i].to] && edge[i].to!=k) Dfs2(edge[i].to,edge[i].to);
}

inline int Lca(int u,int v) 
{
    while (true)
    {
        if (top[u]==top[v]) return dep[u]>dep[v]?v:u;
        if (dep[top[u]]>dep[top[v]]) u=father[top[u]]; else v=father[top[v]];
    }
}
//==================================================

inline void push_up(int o) {sum[o]=sum[o<<1]+sum[o<<1|1];}
inline void Clr(int o) {clr[o]=1; sum[o]=0;}
inline void push_down(int o) {if (clr[o]) Clr(o<<1),Clr(o<<1|1); clr[o]=0;}
void Modify(int o,int l,int r,int p,int q)
{
    if (l==p && r==q)
    {
        sum[o]=0;
        clr[o]=1;
        return;
    }
    push_down(o);
    int mid=(l+r)>>1;
    if (q<=mid) Modify(o<<1,l,mid,p,q);
    if (p>=mid+1) Modify(o<<1|1,mid+1,r,p,q);
    if (p<=mid && q>=mid+1) Modify(o<<1,l,mid,p,mid),Modify(o<<1|1,mid+1,r,mid+1,q);
    push_up(o);
}
int Query(int o,int l,int r,int p,int q)
{
    if (l==p && r==q) return sum[o];
    push_down(o);
    int mid=(l+r)>>1;
    if (q<=mid) return Query(o<<1,l,mid,p,q);
    if (p>=mid+1) return Query(o<<1|1,mid+1,r,p,q);
    if (p<=mid && q>=mid+1) return Query(o<<1,l,mid,p,mid)+Query(o<<1|1,mid+1,r,mid+1,q);
}
void Build(int o,int l,int r)
{
    if (l==r)
    {
        sum[o]=1; 
        return;
    }
    int mid=(l+r)>>1;
    Build(o<<1,l,mid),Build(o<<1|1,mid+1,r);
    push_up(o);
}

//=================================================
void Tree_Modify(int u,int v)
{
    while (top[u]!=top[v])
    {
        Modify(1,1,scc,num[top[u]],num[u]);
        u=father[top[u]];
    }
    Modify(1,1,scc,num[v],num[u]);
}
int Tree_Query(int u,int v) 
{
    int ret=0;

    while (top[u]!=top[v])
    {
         ret+=Query(1,1,scc,num[top[u]],num[u]);
        u=father[top[u]];
    }
    ret+=Query(1,1,scc,num[v],num[u]);
    return ret;
}
//=================================================
void Tarjan(int u,int fa)
{
    Low[u]=Dfn[u]=++Stamp; Stack[++apex]=u;
    for(int i=head[u];i!=-1;i=edge[i].next)
        if (edge[i].to!=fa)
        {
            int v=edge[i].to;
            if(!Dfn[v])
            {
                Tarjan(v,u);
                Low[u]=Min(Low[u],Low[v]);
                if(Low[v]>Dfn[u])
                {
                    scc++;
                    while(true) {int x=Stack[apex--]; Belong[x]=scc; if(x==v)break;}
                }
            }
            else Low[u]=Min(Low[u],Dfn[v]);
        }
    if(fa<0)
    {
        scc++;
        while(true){int x=Stack[apex--]; Belong[x]=scc;    if(x==u)break;}
    }
}
//=================================================

int main()
{
    //freopen("c.in","r",stdin);
    Get_Int(n),Get_Int(m);
    for (int i=1;i<=m;i++)
        Get_Int(u),Get_Int(v),Edge[mp(u,v)]=true,Edge[mp(v,u)]=true;

    for (Q=1;;Q++)
    {
        Get_Int(Op[Q].type); if (Op[Q].type==-1) break;
        Get_Int(Op[Q].u),Get_Int(Op[Q].v);
        if (Op[Q].type==0) Edge[mp(Op[Q].u,Op[Q].v)]=false,Edge[mp(Op[Q].v,Op[Q].u)]=false;
    }
    Q--;
    stamp=Stamp=cnt=0;
    memset(head,-1,sizeof(head));
    memset(vis,false,sizeof(vis));
    memset(Low,0,sizeof(Low));
    memset(Dfn,0,sizeof(Dfn));

    Build_G();
    Tarjan(1,-1);
    Clear_G();
    for (int i=1;i<=n;i++)
        for (int j=head[i];j!=-1;j=edge[j].next)
            if (Belong[i]!=Belong[edge[j].to]) 
            {
                if (S.count(mp(Belong[i],Belong[edge[j].to]))==1) continue;
                S.insert(mp(Belong[i],Belong[edge[j].to]));
                S.insert(mp(Belong[edge[j].to],Belong[i]));
                V.pb(mp(Belong[i],Belong[edge[j].to]));
                V.pb(mp(Belong[edge[j].to],Belong[i]));
            }
    

    memset(head,-1,sizeof(head));cnt=0;
    for (int i=0;i<V.size();i++) Add(V[i].fi,V[i].se);
    father[1]=1;dep[1]=1;
    memset(vis,false,sizeof(vis)),Dfs1(1);
    memset(vis,false,sizeof(vis)),Dfs2(1,1);
    Build(1,1,scc);
    for (int i=Q;i>=1;i--)
    {
        int p=Belong[Op[i].u],q=Belong[Op[i].v];
        if (Op[i].type==0)
        {
            if (p==q) continue;
            int t=Lca(p,q);
            if (t==p) 
            {
                int k=0;
                for (int j=head[t];j!=-1;j=edge[j].next)
                    if (Lca(edge[j].to,q)==edge[j].to && father[t]!=edge[j].to) {k=edge[j].to; break;}

                Tree_Modify(q,k);
                continue;
            }

            if (t==q) 
            {
                int k=0;
                for (int j=head[t];j!=-1;j=edge[j].next)
                    if (Lca(edge[j].to,p)==edge[j].to && father[t]!=edge[j].to) {k=edge[j].to; break;}
                Tree_Modify(p,k);
                continue;
            }
            int r,s;
            for (int j=head[t];j!=-1;j=edge[j].next)
                if (Lca(edge[j].to,p)==edge[j].to && father[t]!=edge[j].to) {r=edge[j].to; break;}
            for (int j=head[t];j!=-1;j=edge[j].next)
                if (Lca(edge[j].to,q)==edge[j].to && father[t]!=edge[j].to) {s=edge[j].to; break;}
            Tree_Modify(p,r),Tree_Modify(q,s);
        } else 
        if (Op[i].type==1)
        {
            if (p==q) {Ans[i]=0; continue;}
            int t=Lca(p,q);
            if (t==p) 
            {
                int k=0;
                for (int j=head[t];j!=-1;j=edge[j].next)
                    if (Lca(edge[j].to,q)==edge[j].to && father[t]!=edge[j].to) {k=edge[j].to; break;}
                Ans[i]=Tree_Query(q,k);
                continue;
            }
            if (t==q) 
            {
                int k=0;
                for (int j=head[t];j!=-1;j=edge[j].next)
                    if (Lca(edge[j].to,p)==edge[j].to && father[t]!=edge[j].to) {k=edge[j].to; break;}
                Ans[i]=Tree_Query(p,k);
                continue;
            }
            
            int r,s;
            for (int j=head[t];j!=-1;j=edge[j].next)
                if (Lca(edge[j].to,p)==edge[j].to && father[t]!=edge[j].to) {r=edge[j].to; break;}
            for (int j=head[t];j!=-1;j=edge[j].next)
                if (Lca(edge[j].to,q)==edge[j].to && father[t]!=edge[j].to) {s=edge[j].to; break;}
            Ans[i]=Tree_Query(p,r)+Tree_Query(q,s);
        }
    }
    for (int i=1;i<=Q;i++) 
        if (Op[i].type==1) Put_Int(Ans[i]);
    return 0;
}