Hdu 5458 Stability (LCA + 并查集 + 树状数组 + 缩点)

题目链接：

　　Hdu 5458 Stability

题目描述：

　　给出一个还有环和重边的图G，对图G有两种操作：

　　1 u v, 删除u与v之间的一天边 (保证这个边一定存在)

　　2 u v, 查询u到v的路径上有几条桥。

解题思路：

　　这个题目有很多次操作，包含查询和删边两类，首先想到的是连通分量加缩点。如果按照顺序来，删边时候求桥就是问题了。所以可以离线处理，然后一边记录答案一边加边缩点。

　　对于一个图，把连通分量缩成一个点后，这个图就成为了一棵树， 然后深度差就等于桥的数目。查询的时候对于(u, v)桥的数目等于(设定deep[x]为x的深度，LCA(x, y)为(x, y)的父节点) deep[u] + deep[v] - 2 * deep[LCA(u, v)];

　　现在问题就成了怎么才能更快的缩点和维护点的深度。

　　缩点问题：在树上加上一条边就会形成一个环，然后这个环(强连通分量)上点就会被缩成一个点，然后用并查集来维护强联通分量，每次只需要合并父节点(每个点只能被缩一次，复杂度被平摊还是很可观的)。

　　维护节点深度：每次儿子节点合并到父亲节点的时候，儿子节点的子孙节点的深度都要减一。在这里我们可以用dfs序 + 树状数组来维护节点的深度。利用树状数组的区间更改点查询优化维护深度的操作。

　　还有最后一个问题就是计算(u, v)节点之间桥数目的时候，需要用到LCA，可以利用树上倍增LCA来优化时间复杂度。

这个题目还是很值得本扎扎练手的，考察了很多东西，真是把压箱底的东西都翻出来晒了晒，仰慕当场ac的聚聚们。

#include <vector>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 30010;
const int N = 100010;
const int M = 16;

struct node
{
    int to, del;
    node(int x):to(x),del(0) {}
    bool operator < (const node & a) const
    {
        if (to != a.to) return to < a.to;
        return del > a.del;
    }
};
vector <node> vec[maxn];

struct Query
{
    int op, u, v;
    void read ()
    {
        scanf ("%d %d %d", &op, &u, &v);
        if (op == 1)
        {
            lower_bound (vec[u].begin(), vec[u].end(), node(v)) -> del = true;
            lower_bound (vec[v].begin(), vec[v].end(), node(u)) -> del = true;
        }
    }
} query[N];

int n, m, q;

void init ()
{
    for (int i=0; i<=n; i++)
        vec[i].clear();
}

struct bit_tree
{
    int tree[maxn];
    
    void init()
    {
        memset (tree, 0, sizeof(tree));
    }
    
    int lowbit (int x)
    {
        return x & (-x);
    }
    
    void change (int x, int num)
    {
        while (x <= n)
        {
            tree[x] += num;
            x += lowbit (x);
        }
    }
    
    void update (int x, int y, int num)
    {
        change (x, num);
        change (y+1, -num);
    }
    
    int query (int x)
    {
        int res = 0;
        while (x)
        {
            res += tree[x];
            x -= lowbit (x);
        }
        return res;
    }
    
}Bit_tree;

int begin_id[maxn], end_id[maxn], deep[maxn], ntime;
int fa[maxn][M];
void dfs (int u, int father, int dep)
{
    if (father > 0)
        vec[u].erase (lower_bound(vec[u].begin(), vec[u].end(), node(father)));
        
    fa[u][0] = father;
    begin_id[u] = ++ntime;
    deep[u] = dep;
    
    for (int i=0; i<vec[u].size(); i++)
    {
        node p = vec[u][i];
        if (p.del || begin_id[p.to]) continue;
        vec[u][i].del = true;
        dfs (p.to, u, dep+1);
    }
    
    end_id[u] = ntime;
    Bit_tree.update (begin_id[u], end_id[u], 1);
}

struct Lca
{
    void init ()
    {
        for (int i=1; i<M; i++)
            for (int j=1; j<=n; j++)
                fa[j][i] = fa[fa[j][i-1]][i-1];
    }
    
    int lca (int u, int v)
    {
        if (deep[u] < deep[v])   swap (u, v);
        int num = deep[u] - deep[v];
        for (int i=0; i<M; i++)
            if ((1<<i) & num)   u = fa[u][i];
        if (u == v) return u;
        for (int i=M-1; i>=0; i--)
            if (fa[u][i] != fa[v][i])
            {
                u = fa[u][i];
                v = fa[v][i];
            }
        return fa[u][0];
    }
    
}LCA;

int father[maxn];
struct UNion
{
    void init()
    {
        for (int i=0; i<=n; i++)
            father[i] = i;
    }
    
    int find (int x)
    {
        if (x != father[x]) father[x] = find (father[x]);
        return father[x];
    }
    
    void merge_fa (int x, int y)
    {
        x = find (x);
        while (x != y)
        {
            int t = find(fa[x][0]);
            father[x] = t;
            Bit_tree.update(begin_id[x], end_id[x], -1);
            x = t;
        }
    }
    
    void merge (int x, int y)
    {
        int l = find (LCA.lca (x, y));
        merge_fa (x, l);
        merge_fa (y, l);
    }
    
}Union;

int ans[N], res;
void solve ()
{
    Bit_tree.init ();
    ntime = res = 0;
    memset (begin_id, 0, sizeof(begin_id));
    dfs (1, 0, 1);
    LCA.init ();
    Union.init();
    
    for (int i=1; i<=n; i++)
    {
        for (int j=0; j<vec[i].size(); j++)
        {
            node p = vec[i][j];
            if (p.del)  continue;
            Union.merge (p.to, i);
        }
    }

    for (int i=q; i>0; i--)
    {
        Query p = query[i];
        int u = begin_id[p.u];
        int v = begin_id[p.v];
        int x = begin_id[LCA.lca(p.u, p.v)];
        if (p.op == 1)
            Union.merge(p.u, p.v);
        else
            ans[++ res] = Bit_tree.query(u) + Bit_tree.query(v) - 2*Bit_tree.query(x);
    }
    
    while(res)
        printf ("%d
", ans[res --]);
}

int main ()
{
    int t, u, v;
    scanf ("%d", &t);
    
    for (int i=1; i<=t; i++)
    {
        scanf("%d %d %d", &n, &m, &q);
        init ();
        
        for (int j=0; j<m; j++)
        {
            scanf ("%d %d", &u, &v);
            vec[u].push_back (node(v));
            vec[v].push_back (node(u));
        }
        
        for (int j=1; j<=n; j++)
            sort (vec[j].begin(), vec[j].end());
            
        for (int j=1; j<=q; j++)
            query[j].read();
            
        printf ("Case #%d:
", i);
        solve ();
        
    }
    return 0;
}