【边双连通分量 && LCA】POJ - 3694 Network

Problem Description

输入n,m分别代表有n台电脑，m条线路。接下来m行，每行u,v代表u-v之间有线路连接。输入q,代表有q次访问，每次访问输入u,v问你连接u-v后，还有几个桥

思路：

LCA是用来求缩点u - 缩点v之间有多少条桥先按边双连通分量缩点，按照缩点后建图，然后以1为根，建树，求每个点的父亲和深度。接着就是求LCA，经过过的点标记一下（经过的点另外构成了边双连通分量），没标记过的点，经过会使得桥的数量–

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define mm 200055
#define nn 100055
struct node
{
    int to, next;
};
node Map[2 * mm];
int head[nn], low[nn], dfn[nn], vis[nn], Stack[nn], n, sig, top, N;
//vis[i]代表i这个点属于vis[i]这个边双连通分量
node MAP[mm];
int parent[nn], depth[nn], f[nn];
int cc, ans;
void add(int u, int v, int &cnt)//前向星存图
{
    Map[cnt].to = v;
    Map[cnt].next = head[u];
    head[u] = cnt++;
}
void tardfs(int u, int father)//按边双连通分量缩点
{
    low[u] = dfn[u] = sig++;
    Stack[top++] = u;
    for(int i = head[u]; ~i; i = Map[i].next)
    {
        int to = Map[i].to;
        if(!dfn[to])
        {
            tardfs(to, i);
            low[u] = min(low[u], low[to]);
            if(low[to] > dfn[u])//割边，记录割边两端的点。记录割边的数量
            {
                ans++;
                MAP[cc].to = u;
                MAP[cc++].next = to;
            }
        }
        else if(!vis[to] && i != (father ^ 1))//有重边，就是1-2可能有两条不同的道路。所以同一条道路不能回去，不是同一条可以回去
        {
            low[u] = min(low[u], dfn[to]);
        }
    }
    if(low[u] == dfn[u])
    {
        N++;
        do
        {
            int t = Stack[top - 1];
            vis[t] = N;
            top--;
        }while(Stack[top] != u);
    }
}
void tarjan()
{
    sig = 1, top = 0, N = 0, top = 0, cc = 0;
    memset(vis, 0, sizeof(vis));
    memset(dfn, 0, sizeof(dfn));
    for(int i = 1; i <= n; i++)
    {
        if(!vis[i]) tardfs(i, i);
    }
}
void dfs(int u, int p, int d)//求每个点的父亲，和深度
{
    parent[u] = p;
    depth[u] = d;
    for(int i = head[u]; ~i; i = Map[i].next)
    {
        int to = Map[i].to;
        if(to != p) dfs(to, u, d + 1);
    }
}
void LCA(int u, int v)
{
    while(depth[u] > depth[v]){//u比较深，所以u先到和v一样深的地方
        if(!f[u])//没有标记过，代表u-parent[u]这个桥，还是桥，标记过代表不是桥了。因为有其他的道路可以到parent[u]了。
        {
            ans--;
            f[u] = 1;
        }
        u = parent[u];
    }
    while(depth[v] > depth[u]){//v比较深，所以v先到和u一样深的地方
        if(!f[v])
        {
            ans--;
            f[v] = 1;
        }
        v = parent[v];
    }
    while(u != v)//找公共的祖先
    {
        if(!f[v])
        {
            ans--;
            f[v] = 1;
        }
        if(!f[u])
        {
            ans--;
            f[u] = 1;
        }
        u = parent[u];
        v = parent[v];
    }
}
void rebuild(int &cnt)//缩点后建树
{
    cnt = 0;
    memset(head, -1, sizeof(head));
    for(int i = 0; i < cc; i++)
    {
        int u = MAP[i].to, v = MAP[i].next;
        if(vis[u] != vis[v])
        {
            add(vis[u], vis[v], cnt);
            add(vis[v], vis[u], cnt);
        }
    }
    dfs(1, -1, 1);//求每个点的父亲，和深度
}
int main()
{
    int m, u, v, q, cas = 1;
    while(~scanf("%d %d", &n, &m))
    {
        if(!n && !m) break;
        int cnt = 0;
        memset(head, -1, sizeof(head));
        while(m--)
        {
            scanf("%d %d", &u, &v);
            add(u, v, cnt);
            add(v, u, cnt);
        }
        ans = 0;//桥的数量
        tarjan();//边双连通分量 缩点。
        rebuild(cnt);//缩点后，建树
        scanf("%d", &q);
        printf("Case %d:\n", cas++);
        memset(f, 0, sizeof(f));
        while(q--)
        {
            scanf("%d %d", &u, &v);
            if(ans == 0) {//桥的数量已经为0，再加边也还是0，所以直接输出就好了。
                printf("%d\n", ans);
                continue;
            }
            LCA(vis[u], vis[v]);
            printf("%d\n", ans);
        }
        printf("\n");
    }
}