HDU 4005 边双联通分量

点击打开链接

题意：给一个无向图，然后这个图可以加一条边，现在要求你剪断一条边，使得图不连通，问你剪的这条边的最小费用

思路：先将大牛的思路贴出点这里，首先要缩点肯定是没问题的，然后我写了一个多于的树的直径，就是判断这个树是不是一条链（多于的一步），多于缩完点后的这个树，每条边都有一个权值，现在敌人为了使得我们的花费最大，那么他一定是尽量将小的边都连在一起，那么可以先找的最小费用的边，这条边一定会被连起来，那么一这条边出发，因为尽量将费用小的连起来，那么对于一个节点来说，若它有来两个儿子，那么肯定是连费用小的儿子，推荐上边链接的博客会更清晰

#include <queue>
#include <vector>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int inf=0x3f3f3f3f;
const ll INF=0x3f3f3f3f3f3f3f3fll;
const int maxn=10010;
struct edge{
    int to,ccc;
    edge(int a,int c){to=a;ccc=c;}
};
vector<edge>G[maxn],GG[maxn];
int L[maxn],E[maxn],vis[maxn],stack1[maxn];
int n,m,k,kk,cnt,fans,max1,U,V;
void dfs(int x,int fa){
    vis[x]=1;L[x]=k;E[x]=k++;stack1[kk++]=x;
    int flag=0;
    for(unsigned int i=0;i<G[x].size();i++){
        edge e=G[x][i];
        if(e.to!=fa){
            if(!vis[e.to]){
                dfs(e.to,x);
                L[x]=min(L[x],L[e.to]);
            }else L[x]=min(L[x],E[e.to]);
        }else{
            if(flag) L[x]=min(L[x],E[e.to]);
            flag++;
        }
    }
    if(L[x]==E[x]){
        while(stack1[kk]!=x&&kk>0){
            L[stack1[kk-1]]=L[x];
            kk--;
            vis[stack1[kk]]=0;
        }
    }
}
void tarjan(){
    memset(L,0,sizeof(L));
    memset(E,0,sizeof(E));
    memset(stack1,0,sizeof(stack1));
    kk=0;k=1;dfs(1,1);
    for(int i=1;i<=n;i++){
        for(unsigned int j=0;j<G[i].size();j++){
            edge e=G[i][j];
            if(L[i]!=L[e.to]){
                cnt++;
                if(e.ccc<max1){
                    max1=e.ccc;U=L[i];V=L[e.to];
                }
                GG[L[i]].push_back(edge(L[e.to],e.ccc));
            }
        }
    }
}
int dis[maxn],v[maxn];
void bfs(int s){
    memset(dis,0,sizeof(dis));
    memset(v,0,sizeof(v));
    v[s]=1;dis[s]=0;
    queue<int>que;
    que.push(s);
    while(!que.empty()){
        int u=que.front();que.pop();
        for(unsigned int i=0;i<GG[u].size();i++){
            edge e=GG[u][i];
            if(v[e.to]==0){
                v[e.to]=1;
                dis[e.to]=dis[u]+1;
                que.push(e.to);
            }
        }
    }
}
int slove(int s){
    int max1=0,pos=s;
    bfs(s);
    for(int i=1;i<=n;i++){
        if(dis[i]>max1){
            pos=i;max1=dis[i];
        }
    }
    bfs(pos);
    int ans=0;
    for(int i=1;i<=n;i++){
        if(dis[i]>ans) ans=dis[i];
    }
    return ans;
}
int FDFS(int u,int v){
    int min1=inf,min2=inf;
    for(unsigned int i=0;i<GG[u].size();i++){
        edge e=GG[u][i];
        if(e.to==v) continue;
        int tmp=FDFS(e.to,u);
        tmp=min(tmp,e.ccc);
        if(tmp<min1){
            min2=min1;min1=tmp;
        }else if(tmp<min2){
            min2=tmp;
        }
    }
    fans=min(fans,min2);
    return min1;
}
int main(){
    int a,b,c;
    while(scanf("%d%d",&n,&m)!=-1){
        for(int i=0;i<maxn;i++){
            G[i].clear();GG[i].clear();vis[i]=0;
        }
        for(int i=1;i<=m;i++){
            scanf("%d%d%d",&a,&b,&c);
            G[a].push_back(edge(b,c));
            G[b].push_back(edge(a,c));
        }
        max1=inf;cnt=0;tarjan();
        int ans1=slove(1);
        if(cnt==ans1*2) printf("-1\n");
        else{
            fans=inf;
            FDFS(U,V);
            FDFS(V,U);
            if(fans==inf) printf("-1\n");
            else printf("%d\n",fans);
        }
    }
    return 0;
}