HDU 5458 Stability 树链剖分

题意：给一个图G，n个点m个边，

q次操作

操作1：删除ab之间的一条边

操作2：查询ab之间的稳定性

关于稳定性的定义：就是a与b之间存在多少条边，一旦去掉之后，a与b将不在联通，也就是有多少条a-b的割边（不知道说法对不对）

对于a到b的图来说，如果之间有环，我们可以缩成一个点，那么最后必将是一条链，我们统计边的条数，便是他们的稳定性了。

询问是每次删边，不好处理，如果我们反过来做，那就相当于每次add一条边进图，逆序处理询问，问题相对简单了。

对于原图的话，每次加入一条边之后，就会形成一个环，该怎么缩点呢？缩点我没想到怎么实现，但是如果我们的原图是一棵树呢？

那么其实如果形成环的话，我们并不需要真的缩点或者把该边加入，其效果等同于直接把树上的这一条链的边权赋0（原来是1）

那么问题就简单了。

从输入的m条边里，我们dfs跑一下，找出一个生成树。

然后我们开始把剩余的边加入，每次加一条边，就会形成一个环，等价把树上对应的链的边权赋0.

然后我们把图处理一下，把询问里要删的边先去掉，这样构成了一颗不包含询问的边的树。

然后逆序处理询问，如果是delete边，我们就加入该边，

如果是查询答案就去查对应的链的值。

【注意特判自环（自环的add和查询操作）】

复杂度nlognlogn

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
typedef long long ll;
const int MAXN = 201324+50;
const int N = 100005  ;

int n,m,q;
struct Edge
{
    int to,next;
} edge[MAXN*2];
int head[MAXN],tot;
int top[MAXN];//top[v]表示v所在的重链的顶端节点
int fa[MAXN]; //父亲节点
int deep[MAXN];//深度
int num[MAXN];//num[v]表示以v为根的子树的节点数
int p[MAXN];//p[v]表示v与其父亲节点的连边在线段树中的位置
int fp[MAXN];//和p数组相反
int son[MAXN];//重儿子
int pos;
int out[MAXN];//dfs序
void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
    pos = 0;
    memset(son,-1,sizeof(son));

}
void addedge(int u,int v)
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
}
void dfs1(int u,int pre,int d) //第一遍dfs求出fa,deep,num,son
{
    deep[u] = d;
    fa[u] = pre;
    num[u] = 1;
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if(v != pre)
        {
            dfs1(v,u,d+1);
            num[u] += num[v];
            if(son[u] == -1 || num[v] > num[son[u]])
                son[u] = v;
        }
    }
}
void getpos(int u,int sp) //第二遍dfs求出top和p
{
    top[u] = sp;
    p[u] = ++pos;
    fp[p[u]] = u;
    if(son[u]!=-1)
        getpos(son[u],sp);
    for(int i = head[u] ; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if(v != son[u] && v != fa[u])
            getpos(v,v);
    }
    out[u]=pos;
}

struct TREE
{

int  sum[4*N], add[4*N] ;
void pushDown(int i, int l, int r)		//把i节点的延迟标记传递到左右儿子节点
{
    if(add[i] != -1)
	{
        int mid = (l + r) >> 1;
        add[i << 1] = add[i];
        sum[i << 1] = (mid - l + 1) * add[i];  //[l, mid]代表左儿子区间
        add[i << 1 | 1] = add[i];
        sum[i << 1 | 1] = (r - mid) * add[i];  //[mid + 1, r]代表右儿子区间
        add[i] = -1;
    }
}
void update(int i, int l, int r, int ql, int qr, int val) //更新区间为qlqr,当前区间为l,r,代表当前区间和的节点为i，更新值为val,
{
    if(l > qr || ql > r)		//更新区间不在当前区间内
        return ;
    if(l >= ql && r <= qr)	//要更新的区间把当前区间完全包括，则把当前整个区间+val，然后返回上一层
	{
        sum[i] = 0;//(r - l + 1) * val;
        add[i] = 0;//val;
        return ;
    }
    pushDown(i, l, r);			//如果上面没reutrn 表示要往左右儿子区间查询，所以把延迟标记放下去
    int mid = (l + r) >> 1;
    update(i << 1, l, mid, ql, qr, val);
    update(i << 1 | 1, mid + 1, r, ql, qr, val);
    sum[i] = sum[i << 1] + sum[i << 1 | 1];
}

int query(int i, int l, int r, int ql, int qr)	 //查询区间为qlqr,当前区间为l,r,代表当前区间和的节点为i
{
    if(l > qr || ql > r)
        return 0;
    if(l >= ql && r <= qr)
        return sum[i];
    pushDown(i, l, r);				//同update
    int mid =( l + r) >> 1;
    return query(i << 1, l, mid, ql, qr)
        + query(i << 1 | 1, mid + 1, r, ql, qr);
		//return (t1+t2*prime[mid-max(l,ql)+1])%mod;由于t1可能是属于return 0的情况，所以需要取max(l,ql)，意义是取t1的有效长度

}

    void update_edge(int u,int v)//查询u->v链的sum
    {
        int f1=top[u],f2=top[v];
        ll tmp=0;
        while(f1!=f2)
        {
            if (deep[f1]<deep[f2])
            {
                swap(f1,f2);
                swap(u,v);
            }
             update(1,1,pos,p[f1],p[u],0);

            u=fa[f1],f1=top[u];
        }
        if (deep[u]>deep[v] ) swap(u,v);
          update(1,1,pos,p[son[u]],p[v],0); //若val(u)是u到fu的边权,则用son[u]

    }
    int  query_edge(int u,int v)//查询u->v链的sum
    {
        int f1=top[u],f2=top[v];
        int tmp=0;
        while(f1!=f2)
        {
            if (deep[f1]<deep[f2])
            {
                swap(f1,f2);
                swap(u,v);
            }
             tmp+=query(1,1,pos,p[f1],p[u]);

            u=fa[f1],f1=top[u];
        }
        if (deep[u]>deep[v] ) swap(u,v);
        tmp+=query(1,1,pos,p[son[u]],p[v]);//若val(u)是u到fu的边权,则用son[u]
        return tmp;
    }
    void build(int l,int r,int i)    //  线段树的建立；
{
    add[i]=-1;    //add[rt]=aa[++ok];
    sum[i]=0;              //  用了lazy思想，提高了效率；
    if(l==r)
    {
        sum[i]=add[i]=1;
        return;
    }
    int mid=(l+r)>>1;
    build(l,mid,i<<1);
    build(mid+1,r,i<<1|1);
    sum[i] = sum[i << 1] + sum[i << 1 | 1];
}
};
TREE tp;
multiset<int> s[MAXN];

struct Q
{
    int op;
    int u,v;
} qq[MAXN];
vector<int  > G[MAXN];
int vis[MAXN];
int father[MAXN];
void dfs(int u)
{
    vis[u]=1;
    for (int i=0; i<G[u].size(); i++)
    {
        int v=G[u][i];
        if (!vis[v])
        {
            father[v]=u;
            dfs(v);
        }
    }
}

int ans[MAXN];
int main()
{

    int cnt=1;
  //  freopen("in.txt","r",stdin);
    int t;
    cin>>t;
    while(t--)
    {
        init();
        scanf("%d%d%d",&n,&m,&q);
         tp.build(1,n,1);
        tp.update(1,1,pos,1,1,0);
        for (int i=1; i<=n; i++)
            s[i].clear();
        int u,v;
        for (int i=1; i<=m; i++)
        {
            scanf("%d%d",&u,&v);
            s[u].insert(v);
            s[v].insert(u);
        }
        for (int i=1; i<=q; i++)
        {
            scanf("%d%d%d",&qq[i].op,&qq[i].u,&qq[i].v);
            if (qq[i].op==1)
            {
                int u=qq[i].u,v=qq[i].v;
                s[u].erase(s[u].find(v));
                s[v].erase(s[v].find(u));
            }
        }
        for (int i=1; i<=n; i++)
        {
            G[i].clear();
            multiset<int>::iterator it;
            for (it=s[i].begin(); it!=s[i].end(); it++)
                G[i].push_back(*it);
        }
        memset(vis,0,sizeof(vis));
        memset(father,0,sizeof(father));
        dfs(1);
        for (int i=1; i<=n; i++)
        {
            for (int j=0; j<G[i].size(); j++)
            {

               int u=i,v=G[i][j];
               if (u==father[v]||v==father[u])
               {
                   // printf("(%d,%d)\n",u,v);
                    addedge(u,v);
                   // addedge(v,u);
                }
            }
        }
        dfs1(1,0,0);
        getpos(1,1);

         for (int i=1; i<=n; i++)
        {
            for (int j=0; j<G[i].size(); j++)
            {
                int u=i,v=G[i][j];
               if (u!=father[v]&&v!=father[u]&& u!=v)
                {
                     tp.update_edge(u,v);
                }
            }
        }

        for (int i=q; i>=1; i--)
        {
            int op=qq[i].op;
            int u=qq[i].u,v=qq[i].v;
            if (op==1)
            {
                if (u!=v)
                    tp.update_edge(u,v);
            }

            else
            {
                if (u==v) ans[i]=0;
                else ans[i]=tp.query_edge(u,v);
            }

        }

        printf("Case #%d:\n",cnt++);

        for (int i=1; i<=q; i++)
        {
            if (qq[i].op==2)
            printf("%d\n",ans[i]);
        }
    }

    return 0;

}