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=;  char ch=getchar(); int f=;
     while (ch<'' || ch>'') {if (ch=='-') f=-; ch=getchar();}
     while (ch>='' && ch<='') {x=x*+ch-''; ch=getchar();} x*=f;
 }
 inline void Put_Int(int x)
 {
     char ch[]; int top=;
     if (x==) ch[++top]='';
     while (x) ch[++top]=x%+'',x/=;
     while (top) putchar(ch[top--]); putchar('\n');
 }
 //===================================================
 const int Maxm=;
 const int Maxn=;
 const int Maxop=;
 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<<],clr[Maxn<<];
 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]=;
     for (int i=head[u];i!=-;i=edge[i].next)
         if (!vis[edge[i].to])
         {
             father[edge[i].to]=u;
             dep[edge[i].to]=dep[u]+;
             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=;
     for (int i=head[u];i!=-;i=edge[i].next)
         if (!vis[edge[i].to] && (siz[edge[i].to]>siz[k] || k==)) k=edge[i].to;
     if (k==) return;
     Dfs2(k,chain);
     for (int i=head[u];i!=-;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<<]+sum[o<<|];}
 inline void Clr(int o) {clr[o]=; sum[o]=;}
 inline void push_down(int o) {if (clr[o]) Clr(o<<),Clr(o<<|); clr[o]=;}
 void Modify(int o,int l,int r,int p,int q)
 {
     if (l==p && r==q)
     {
         sum[o]=;
         clr[o]=;
         return;
     }
     push_down(o);
     int mid=(l+r)>>;
     if (q<=mid) Modify(o<<,l,mid,p,q);
     if (p>=mid+) Modify(o<<|,mid+,r,p,q);
     if (p<=mid && q>=mid+) Modify(o<<,l,mid,p,mid),Modify(o<<|,mid+,r,mid+,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)>>;
     if (q<=mid) return Query(o<<,l,mid,p,q);
     if (p>=mid+) return Query(o<<|,mid+,r,p,q);
     if (p<=mid && q>=mid+) return Query(o<<,l,mid,p,mid)+Query(o<<|,mid+,r,mid+,q);
 }
 void Build(int o,int l,int r)
 {
     if (l==r)
     {
         sum[o]=;
         return;
     }
     int mid=(l+r)>>;
     Build(o<<,l,mid),Build(o<<|,mid+,r);
     push_up(o);
 }

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

     while (top[u]!=top[v])
     {
          ret+=Query(,,scc,num[top[u]],num[u]);
         u=father[top[u]];
     }
     ret+=Query(,,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!=-;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<)
     {
         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=;i<=m;i++)
         Get_Int(u),Get_Int(v),Edge[mp(u,v)]=true,Edge[mp(v,u)]=true;

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

     Build_G();
     Tarjan(,-);
     Clear_G();
     for (int i=;i<=n;i++)
         for (int j=head[i];j!=-;j=edge[j].next)
             if (Belong[i]!=Belong[edge[j].to])
             {
                 if (S.count(mp(Belong[i],Belong[edge[j].to]))==) 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,-,sizeof(head));cnt=;
     for (int i=;i<V.size();i++) Add(V[i].fi,V[i].se);
     father[]=;dep[]=;
     memset(vis,false,sizeof(vis)),Dfs1();
     memset(vis,false,sizeof(vis)),Dfs2(,);
     Build(,,scc);
     for (int i=Q;i>=;i--)
     {
         int p=Belong[Op[i].u],q=Belong[Op[i].v];
         if (Op[i].type==)
         {
             if (p==q) continue;
             int t=Lca(p,q);
             if (t==p)
             {
                 int k=;
                 for (int j=head[t];j!=-;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=;
                 for (int j=head[t];j!=-;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!=-;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!=-;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==)
         {
             if (p==q) {Ans[i]=; continue;}
             int t=Lca(p,q);
             if (t==p)
             {
                 int k=;
                 for (int j=head[t];j!=-;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=;
                 for (int j=head[t];j!=-;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!=-;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!=-;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=;i<=Q;i++)
         if (Op[i].type==) Put_Int(Ans[i]);
     return ;
 }

傻逼树剖280+系列