hdu 4738（双联通缩点）

最新推荐文章于 2021-07-21 13:43:32 发布

原创最新推荐文章于 2021-07-21 13:43:32 发布 · 245 阅读

0 ·

CC 4.0 BY-SA版权

图论专栏收录该内容

51 篇文章

订阅专栏

本文通过一个具体的编程挑战，介绍了如何使用图论中的SCC（强连通分量）算法来解决实际问题。特别关注了在处理含有特殊条件（如边权为0）的图时所需的额外考虑，以及如何通过深度优先搜索（DFS）和Tarjan算法来有效地找出图中的强连通分量。

此题有坑！！！

桥的边权有可能是0，但是这时候要输出1，因为周瑜至少的排一个人去炸呀，那个年代又没有导弹！！！卧槽，有时候还得联系实际！

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<stack>
#include<vector>
using namespace std;
const int inf = 1<<20;
const int maxn = 1005;
int n,m;
struct node
{
    int to;
    int next;
    int w;
    node(){}
    node(int a,int b,int c):to(a),next(b),w(c){}
}edge[1002*1002];
struct Edge
{
    int to;
    int w;
    Edge(int a,int b):to(a),w(b){}
};
vector<Edge>G[maxn];
int head[maxn],dfn[maxn],low[maxn],belong[maxn];
int tot,ti,cnt;
stack<int>s;
void tarjan(int u,int fa)
{
    dfn[u] = ++ti; low[u] = ti;
    s.push(u); int flag = 0;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v = edge[i].to;
        if(v==fa&&flag==0){flag=1;continue;}
        if(!dfn[v])
        {
            tarjan(v,u);
            low[u] = min(low[u],low[v]);
        }
        else if(belong[v]==-1)
        {
            low[u] = min(dfn[v],low[u]);
        }
    }
    if(dfn[u]==low[u])
    {
        int y; cnt++;
        do{
            y = s.top(); s.pop();
            belong[y] = cnt;
        }while(y!=u);
    }
}
int res;
void dfs(int u,int fa)
{
    int len = G[u].size();
    for(int i=0;i<len;i++)
    {
        int v = G[u][i].to;
        if(v==fa) continue;
        res = min(res,G[u][i].w);
        dfs(v,u);
    }
}
void cbh(int u)
{
    dfn[u] = 1;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v = edge[i].to;
        if(!dfn[v])
        {
            dfn[v] = 1;
            cbh(v);
        }
    }
}
int main()
{
    int u,v,w;
    while(scanf("%d%d",&n,&m))
    {
        if(n==0&&m==0) break;
        tot = 0;
        memset(head,-1,sizeof(head));
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            if(u==v) continue;
            edge[tot] = node(v,head[u],w);
            head[u] = tot++;
            edge[tot] = node(u,head[v],w);
            head[v] = tot++;
        }
        int key = 0;
        memset(dfn,0,sizeof(dfn));
        for(int i=1;i<=n;i++)
        {
            if(!dfn[i]){key++;cbh(i);}
        }
        if(key>1){printf("0\n");continue;}
        memset(dfn,0,sizeof(dfn));
        memset(low,0,sizeof(low));
        memset(belong,-1,sizeof(belong));
        ti = 0; cnt = 0;
        for(int i=1;i<=n;i++) if(!dfn[i]) tarjan(i,-1);
        if(cnt==1) {printf("-1\n"); continue; }
        for(int i=1;i<=n;i++) G[i].clear();
        for(int i=1;i<=n;i++)
        {
            for(int j=head[i];j!=-1;j=edge[j].next)
            {
                if(belong[i]!=belong[edge[j].to])
                {
                    G[belong[i]].push_back(Edge(belong[edge[j].to],edge[j].w));
                }
            }
        }
        res = inf;
        dfs(1,-1);
        if(res==0) res++;
        printf("%d\n",res);
    }
    return 0;
}