POJ - 3694 Network (无向图 并查集缩点+割边)

Network
Time Limit: 5000MS   Memory Limit: 65536K
Total Submissions: 10981   Accepted: 4103

Description

A network administrator manages a large network. The network consists of N computers and M links between pairs of computers. Any pair of computers are connected directly or indirectly by successive links, so data can be transformed between any two computers. The administrator finds that some links are vital to the network, because failure of any one of them can cause that data can't be transformed between some computers. He call such a link a bridge. He is planning to add some new links one by one to eliminate all bridges.

You are to help the administrator by reporting the number of bridges in the network after each new link is added.

Input

The input consists of multiple test cases. Each test case starts with a line containing two integers N(1 ≤ N ≤ 100,000) and M(N - 1 ≤ M ≤ 200,000).
Each of the following M lines contains two integers A and B ( 1≤ AB ≤ N), which indicates a link between computer A and B. Computers are numbered from 1 to N. It is guaranteed that any two computers are connected in the initial network.
The next line contains a single integer Q ( 1 ≤ Q ≤ 1,000), which is the number of new links the administrator plans to add to the network one by one.
The i-th line of the following Q lines contains two integer A and B (1 ≤ ABN), which is the i-th added new link connecting computer A and B.

The last test case is followed by a line containing two zeros.

Output

For each test case, print a line containing the test case number( beginning with 1) and Q lines, the i-th of which contains a integer indicating the number of bridges in the network after the first i new links are added. Print a blank line after the output for each test case.

Sample Input

3 2
1 2
2 3
2
1 2
1 3
4 4
1 2
2 1
2 3
1 4
2
1 2
3 4
0 0

Sample Output

Case 1:
1
0

Case 2:
2
0

Source

2008 Asia Hefei Regional Contest Online by USTC

题意:在线求割边数量。操作只有加边。


解题思路:能想到怎么做,但是自己实现有难度……参考了很多代码。首先要做无向图的缩点,生成一棵树,对于每一个查询,看看两个点是否在缩点后的同一个点中(这里用并查集),是的话,答案不变,不是的话,就要把这两点所属的树上的点连起来,再做一次缩点(这里用LCA很快可以解决)。附上两份代码,第一份好理解,没有显示的缩点,直接暴力,第二份用了并查集缩点。


//没有显示的缩点算法  1100+ms

#include 
#include 
#include 
#include 
#include 
using namespace std;
const int MAXN = 100010;
const int MAXM = 200010;
struct edge
{
    int u;
    int v;
    int next;
} e[2 * MAXM];
int edge_num, head[MAXN];
void insert_edge(int u, int v)
{
    e[edge_num].u = u;
    e[edge_num].v = v;
    e[edge_num].next = head[u];
    head[u] = edge_num++;
}

int N, M;
int vistime = 0;
int dfn[MAXN], low[MAXN], vis[MAXN];

int fa[MAXN], isGB[MAXN];
int ans;

void GB(int u, int last)
{
    dfn[u] = low[u] = ++vistime;
    vis[u] = 1;

    for (int i = head[u]; ~i; i = e[i].next)
    {
        int v = e[i].v;
        if (v == last)
            continue;
        if (!vis[v])
        {
            fa[v] = u;
            GB(v, u);
            low[u] = min(low[u], low[v]);
            if (dfn[u] < low[v])
            {
                ans++;
                isGB[v] = 1;
            }
        }
        else
        {
            if (vis[v] == 1)
                low[u] = min(low[u], dfn[v]);
        }
    }
    vis[u] = 2;
}

void LCA(int u, int v)
{
    while (dfn[v] > dfn[u])
    {
        if (isGB[v])
            ans--;
        isGB[v] = 0;
        v = fa[v];
    }

    while (dfn[u] > dfn[v])
    {
        if (isGB[u])
            ans--;
        isGB[u] = 0;
        u = fa[u];
    }

    while (u != v)
    {
        if (isGB[u])
            ans--;
        if (isGB[v])
            ans--;
        isGB[u] = isGB[v] = 0;
        u = fa[u];
        v = fa[v];
    }
}

int main()
{
    int t = 1;
    while (~scanf("%d%d", &N, &M))
    {
        if (N == 0 && M == 0)
            break;
        memset(head, -1, sizeof(head));
        edge_num = 0;
        int u, v;
        for (int i = 0; i < M; i++)
        {
            scanf("%d%d", &u, &v);
            insert_edge(u, v);
            insert_edge(v, u);
        }

        ans = vistime = 0;
        memset(dfn, 0, sizeof(dfn));
        memset(low, 0, sizeof(low));
        memset(isGB, 0, sizeof(isGB));
        memset(vis, 0, sizeof(vis));
        fa[1] = 1;
        GB(1, 0);

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

        int q;
        scanf("%d", &q);
        for (int i = 0; i < q; i++)
        {
            scanf("%d%d", &u, &v);
            LCA(u, v);
            printf("%d\n", ans);
        }
        printf("\n");
    }
}

//显示的用并查集缩点 400+ms

#include 
#include 
#include 
#include 
#include 
using namespace std;
const int MAXN = 100010;
const int MAXM = 200010;

struct edge
{
    int u;
    int v;
    int next;
} e[2 * MAXM];
int edge_num, head[MAXN];
void insert_edge(int u, int v)
{
    e[edge_num].u = u;
    e[edge_num].v = v;
    e[edge_num].next = head[u];
    head[u] = edge_num++;
}

int pre[MAXN];
int find(int x)
{
    return pre[x] == x ? x : pre[x] = find(pre[x]);
}
void join(int x, int y)
{
    int fx = find(x);
    int fy = find(y);
    if (fx != fy)
        pre[fx] = fy;
}

int N, M;
int dfn[MAXN], low[MAXN], vis[MAXN];

int fa[MAXN], isGB[MAXN];
int ans;

void GB(int u, int last, int vistime)
{
    dfn[u] = low[u] = vistime;
    vis[u] = 1;
    fa[u] = last;
    for (int i = head[u]; ~i; i = e[i].next)
    {
        int v = e[i].v;

        if (vis[v] == 1 && v != last)
            low[u] = min(low[u], dfn[v]);

        if (!vis[v])
        {

            GB(v, u, vistime + 1);
            low[u] = min(low[u], low[v]);
            if (dfn[u] < low[v])
            {
                ans++;
            }
            else
            {
                join(u, v);
            }
        }
    }
    vis[u] = 2;
}

void func(int u)
{
    int fx = find(u);
    int fy = find(fa[u]);
    if (fx != fy)
    {
        ans--;
        pre[fx] = fy;
    }
}

void LCA(int u, int v)
{

    while (dfn[u] > dfn[v])
    {
        func(u);
        u = fa[u];
    }

    while (dfn[v] > dfn[u])
    {
        func(v);
        v = fa[v];
    }

    while (u != v)
    {
        func(u);
        func(v);
        u = fa[u];
        v = fa[v];
    }
}

int main()
{
    int t = 1;
    while (~scanf("%d%d", &N, &M))
    {
        if (N == 0 && M == 0)
            break;
        memset(head, -1, sizeof(head));
        edge_num = 0;
        int u, v;
        for (int i = 0; i < M; i++)
        {
            scanf("%d%d", &u, &v);
            insert_edge(u, v);
            insert_edge(v, u);
        }

        ans = 0;
        memset(dfn, 0, sizeof(dfn));
        memset(low, 0, sizeof(low));
        memset(vis, 0, sizeof(vis));
        for (int i = 0; i <= N; i++)
            pre[i] = i;

        GB(1, 0, 1);

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

        int q;
        scanf("%d", &q);
        for (int i = 0; i < q; i++)
        {
            scanf("%d%d", &u, &v);
            if (find(u) != find(v))
                LCA(u, v);
            printf("%d\n", ans);
        }
        printf("\n");
    }
}



你可能感兴趣的:(——图论相关——,ACM,-,割点与割边)