UVA - 10972 RevolC FaeLoN （边双连通分量）

题目大意：给定一个无向图，要求你把所有的无向边变成有向边，并且添加最少的有向边，使得新的有向图强连通

解题思路：这题和POJ - 3352 Road Construction

类似，只不过这题给的不一定是连通图，有可能缩点后出现孤立的点，但大体的思路是一样的

前面的就不详说了，可以看戳这里里面已经写了，这里讲一下怎么处理孤立的点

如果有n个点，要求在这n个点间添加有向边，使得这n个点变成强连通，那么需要添加的边的数量为n

有了上面这个结论，求的时候就比较好办了，处理的时候，只需要统计出所有度为1和度为0的缩点（将块缩成点）的数量即可

假设度为1的数量为A （叶子结点，连通图里面的）

度为2的数量为B（孤立的点）

那么所需要连的边就是(A + 1+ 2 * B) / 2了

附上大神的详解详解

#include <cstdio>
#include <cstring>
#define N 1010
#define M 20010
#define min(a,b) ((a) < (b) ? (a) : (b))

struct Edge{
    int to, next;
}E[M];

int head[N], bridge[N][2], belong[N], degree[N], stack[N], pre[N];
int n, m, tot, dfs_clock, bcc_cnt, bnum, top;

void AddEdge(int u, int v) {
    E[tot].to = v; E[tot].next = head[u]; head[u] = tot++;
    u = u ^ v; v = u ^ v; u = u ^ v;
    E[tot].to = v; E[tot].next = head[u]; head[u] = tot++;
}

void init() {
    memset(head, -1, sizeof(head));
    tot = 0;

    int u, v;
    for (int i = 0; i < m; i++) {
        scanf("%d%d", &u, &v);
        AddEdge(u, v);
    }
}

int dfs(int u, int fa) {
    int lowu = pre[u] = ++dfs_clock;
    stack[++top] = u;

    for (int i = head[u]; i != -1; i = E[i].next) {
        int v = E[i].to;

        if (!pre[v]) {
            int lowv = dfs(v, u);
            lowu = min(lowu, lowv);
            if (lowv > pre[u]) {
                bridge[bnum][0] = u;
                bridge[bnum++][1] = v;

                bcc_cnt++;
                while (1) {
                    int x = stack[top--];
                    belong[x] = bcc_cnt;
                    if (x == v)
                        break;
                }
            }
        }else if(pre[v] < pre[u] && v != fa) {
            lowu = min(lowu, pre[v]);
        }
    }
    return lowu;
}

void solve() {
    memset(pre, 0, sizeof(pre));
    memset(degree, 0, sizeof(degree));
    dfs_clock = bcc_cnt = bnum = top = 0;

    for (int i = 1; i <= n; i++)
        if (!pre[i]) {
            dfs(i, -1);
            bcc_cnt++;
            while(top) {
                int x = stack[top--];
                belong[x] = bcc_cnt;
                if (x == i)
                    break;
            }
        }
    if (bcc_cnt == 1) {
        printf("0\n");
        return ;
    }

    for (int i = 0; i < bnum; i++) {
        int u = bridge[i][0];
        int v = bridge[i][1];
        degree[belong[u]]++;
        degree[belong[v]]++;
    }

    int block = 0;
    for (int i = 1; i <= bcc_cnt; i++)
        if (degree[i] == 0)
            block += 2;
        else if(degree[i] == 1)
            block += 1;
    printf("%d\n", (block + 1) / 2);
}

int main() {
    while (scanf("%d%d", &n, &m) != EOF) {
        init();
        solve();
    }
    return 0;
}

版权声明：本文为博主原创文章，未经博主允许不得转载。