POJ3177 Redundant Paths

最新推荐文章于 2022-11-06 08:06:45 发布

H_Riven

最新推荐文章于 2022-11-06 08:06:45 发布

阅读量131

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/qq_41304844/article/details/79828207

本文介绍了一种求解无向图中任意两点间至少存在两条路径所需的最小边数的方法。利用Tarjan算法进行图的简化处理，并通过计算叶子节点的数量来确定所需的额外边数。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

给定一个无向图，求最少需要多少边可以让这个无向图里两两点之间都有两条路可以走。
先tarjan算法进行缩点，得到一颗无向树
对于无向树中非叶子结点，只要叶子结点连通了，就都有两条路可以走
所以变成了需要多少条边可以把所以叶子结点连通
当叶子结点是奇数时答案就是ans =（ans）/ 2 + 1
当叶子结点是偶数时答案就是ans =（ans）/ 2
所以ans = （ans + 1）/ 2

#include<stdio.h>
#include<string.h>
#include<algorithm>

using namespace std;

int n, m, tol, cnt, top;
int stacksize;
const int maxn = 5005;
const int maxm = 10000;

struct Node{
    int u;
    int v;
    int next;
};
Node node[maxm * 2];
int head[maxn];
int stack[maxn];
int dfn[maxn];
int low[maxn];
int degree[maxn]; 
int fath[maxn];
bool maps[maxn][maxn];
int point[maxn];

void init() {
    top = tol = cnt = stacksize = 0;
    memset(dfn, 0, sizeof(dfn));
    memset(low, 0, sizeof(low)); 
    memset(node, 0, sizeof(node));
    memset(fath, 0, sizeof(fath));
    memset(head, -1, sizeof(head));
    memset(stack, 0, sizeof(stack));
    memset(point, 0, sizeof(point));
    memset(degree, 0, sizeof(degree));
    memset(maps, false, sizeof(maps));
}

void addnode(int u, int v) {
    node[tol].u = u;
    node[tol].v = v;
    node[tol].next = head[u];
    head[u] = tol++;
}

void dfs(int u, int fa) {
    int v;
    stack[stacksize++] = u;
    fath[u] = fa;
    dfn[u] = low[u] = ++cnt;
    for(int i=head[u]; i!=-1; i=node[i].next) {
        v = node[i].v;
        if(!dfn[v]){
            dfs(v, u);
            low[u] = min(low[u], low[v]);
        } else if(v != fa) {
            low[u] = min(low[u], dfn[v]);
        }
    }
    if(dfn[u] == low[u]) {
        top++; 
        do{
            v = stack[--stacksize];
            point[v] = top;
        } while(v != u);
    }
}

void tarjan() {
    for(int u=1; u<=n; u++) {
        if(!dfn[u]) {
            dfs(u, u);
        }
    }
}

void getdegree() {
    for(int u=1; u<=n; u++) {
        for(int i=head[u]; i!=-1; i=node[i].next) {
            int v = node[i].v;
            if(point[u] != point[v] && v != u) {
                degree[point[u]]++;
            }
        }
    }
    int ans = 0;
    for(int i=1; i<=top; i++) {
        if(degree[i] == 1) {
            ans++;
        }
    }
    printf("%d\n", (ans+1)/2);
}

int main() {
    while(scanf("%d%d",&n, &m) != EOF) {
        init();
        for(int i=1; i<=m; i++) {
            int u, v;
            scanf("%d%d",&u, &v);
            if(maps[u][v])
                continue;
            maps[u][v] = maps[v][u] = true;
            addnode(u, v);
            addnode(v, u);
        }
        tarjan();
        getdegree();
    }
    return 0;
}