边双联通分量

（noip模拟赛）化学竞赛的大奖

(prize.pas/c/cpp)

【问题描述】

XYX 在 CChO(全国化学奥林匹克竞赛)比赛中获得了大奖，奖品是一张特殊的机票。
使用这张机票，可以在任意一个国家内的任意城市之间的免费飞行，只有跨国飞行时才
会有额外的费用。XYX 获得了一张地图，地图上有城市之间的飞机航班和费用。已知从
每个城市出发能到达所有城市，两个城市之间可能有不止一个航班。一个国家内的每两
个城市之间一定有不止一条飞行路线， 而两个国家的城市之间只 有一条飞行路线。 XYX
想知道， 从每个城市出发到额外费用最大的城市， 以便估算出出行的费用， 请你帮助他。
当然，你不能通过乘坐多次一个航班增加额外费用， 也就是必须沿费用最少的路线飞
行。

【输入】

第一行，两个整数 N,M，表示地图上有 N 个城市，M 条航线。
接下来 M 行，每行三个整数 a,b,c，表示城市 a,b 之间有一条费用为 c 的航线。

【输出】

共 N 行，第 i 行为从城市 i 出发到达每个城市额外费用的最大值。

【输入输出样例 1】

输入

6 6 
1 4 2 
1 2 6 
2 5 3 
2 3 7 
6 3 4 
3 1 8

输出

4 
4 
4 
6 
7 
7

有四个国家，包含的城市分别为 {1,2,3},{4},{5},{6}。
从城市 1 出发到达城市 6，乘坐(1,3)(3,6)两个航班费用最大，
(1,3)在国内为免费航班，(3,6)的费用为 4，所以从 1 出发的最
大费用为 4。

【数据范围】

对于 40%的数据 1<=N<=1000,1<=M<=1000
对于 100%的数据 1<=N<=20000,1<=M<=200000

分析

模拟赛的一道题，感觉像tarjan缩点，但这是无向图，

但是思想是一样的，所以写了一个乱搞的tarjan，居然a了。。

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

const int N = 50010;
const int M = 500100;

struct Edge{
    int to,w,nxt;
    bool flag;
    Edge() {flag = false;}
}e[M],t[M];
int head[N],tot = 1,headt[N],tott;
int dfn[N],low[N],st[N],top;
int bel[N],dp[N][3],ans[N];
bool vis[N];
int tn,cnt;

inline int read() {
    int x = 0,f =1;char ch = getchar();
    for (; ch<'0'||ch>'9'; ch = getchar())
        if (ch=='-') f = -1;
    for (; ch>='0'&&ch<='9'; ch = getchar())
        x = x*10+ch-'0';
    return x*f;
}


void tarjan(int u,int fa) {
    dfn[u] = low[u] = ++tn;
    st[++top] = u;
    vis[u] = true;
    
    for (int i=head[u]; i; i=e[i].nxt) {
        int v = e[i].to;
        if (!dfn[v]) {
            e[i^1].flag = true;
            tarjan(v,u);
            low[u] = min(low[u],low[v]);
        }
        else {
            if (vis[v] && !e[i].flag) low[u] = min(low[u],dfn[v]);
        }
    }
    
    if (dfn[u]==low[u]) {
        ++cnt;
        do {
            vis[st[top]] = false;
            bel[st[top]] = cnt;
            top--;            
        }while (st[top+1]!=u);
    }
}


inline void add_edge(int u,int v,int w) {
    t[++tott].to = v,t[tott].w = w,t[tott].nxt = headt[u],headt[u] = tott;
    t[++tott].to = u,t[tott].w = w,t[tott].nxt = headt[v],headt[v] = tott;
}

void dfs(int u,int fa) {
    int ts = headt[u];
    for (int i=headt[u]; i; i=t[i].nxt) {
        int v = t[i].to;
        if (v==fa) continue;
        if (vis[v]) continue;
        vis[v] = true;
        dfs(v,u);
        if (dp[v][0] + t[i].w > dp[u][0]) {
            dp[u][1] = dp[u][0];
            dp[u][0] = dp[v][0]+t[i].w;
        }
        else if (dp[v][0]+t[i].w > dp[u][1]) 
            dp[u][1] = dp[v][0]+t[i].w;
    }
}
void dfs2(int u,int fa) {
    
    for (int i=headt[u]; i; i=t[i].nxt) {
        int v = t[i].to;
        if (v==fa) continue;
        if (vis[v]) continue;
        vis[v] = true;
        if (dp[v][0]+t[i].w==dp[u][0]) 
            dp[v][2] = max(dp[u][2],dp[u][1])+t[i].w;
        else dp[v][2] = max(dp[u][2],dp[u][0])+t[i].w;
        dfs2(v,u);
    }
}

int main() {
    
    freopen("prize.in","r",stdin);
    freopen("prize.out","w",stdout);
    
    int n = read(),m = read();
    for (int u,v,w,i=1; i<=m; ++i) {
        u = read(),v = read(),w = read();
        e[++tot].to = v,e[tot].w = w,e[tot].nxt = head[u],head[u] = tot;
        e[++tot].to = u,e[tot].w = w,e[tot].nxt = head[v],head[v] = tot;
    }
    
    /*for (int i=1; i<=n; ++i) 
        if (!dfn[i]) */
    tarjan(1,0);
    
//    for (int i=1; i<=n; ++i) printf("%d ",bel[i]);    
    for (int i=1; i<=n; ++i) 
        for (int j=head[i]; j; j=e[j].nxt) 
            add_edge(bel[i],bel[e[j].to],e[j].w);
    
/*    for (int i=1; i<=4; ++i) {
        printf("%d",headt[i]);
    //    for (int j=headt[i]; j; j=t[j].nxt) 
    //        printf("%d ",t[j].to);
        printf("
");
        
    }*/
    memset(vis,false,sizeof(vis));
    vis[1] = true;
    dfs(1,0);
    memset(vis,false,sizeof(vis));
    vis[1] = true;
    dfs2(1,0);
    
    for (int i=1; i<=cnt; ++i) 
        ans[i] = max(dp[i][0],dp[i][2]);

    for (int i=1; i<=n; ++i) 
        printf("%d
",ans[bel[i]]);
    return 0;
}
/*

6 6
1 4 2
1 2 6
2 5 3
2 3 7
6 3 4
3 1 8


6 6
1 2 1
2 3 1
2 4 1
3 5 1
4 5 1
5 6 1

6 7
1 2 3
2 3 1
3 4 1
4 5 1
2 5 1
4 2 1
4 6 2

7 9
1 2 3
2 3 1
3 4 1
4 5 1
2 5 1
4 2 1
4 6 2
3 7 1
4 7 1

*/

后来知道是边双联通分量。。

概念：任意两点至少存在两条边不重复路径

#include<bits/stdc++.h>
#define maxn 20005
#define maxm 200005
using namespace std;

int n,m,id,dfn[maxn],low[maxn],head[maxn],head2[maxn],cnt;
int dis[maxn],dis1[maxn],mx=0,root;
int belong[maxn],belnum;
bool vis[maxn];
stack<int> stk;
struct Edge{    
int u,v,val,next;
}edge[maxm<<1],e[maxm<<1];

inline int read()
{
    int x=0,f=1;char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}
namespace Tarjan
{ 

inline void add(int u,int v,int val)
{    
    edge[++cnt].v=v;    
    edge[cnt].u=u;    
    edge[cnt].val=val;    
    edge[cnt].next=head[u];    
    head[u]=cnt;
} 

inline void tarjan(int u,int fa)
{    
    dfn[u]=low[u]=++id;    
    vis[u]=1;    
    stk.push(u);    
    for(int i=head[u];i!=-1;i=edge[i].next)    
    {    
        int v=edge[i].v;    
        if(!dfn[v])    
        {    
            tarjan(v,u);    
            low[u]=min(low[u],low[v]);    
        }    
        else if(vis[v]&&v!=fa)    
        {    
            low[u]=min(low[u],dfn[v]);    
        }    
    }    
    if(dfn[u]==low[u])    
    {    
        belnum++;    
        int temp;    
        do{    
            temp=stk.top();    
            belong[temp]=belnum;    
            vis[temp]=0;    
            stk.pop();    
        }while(temp!=u);    
    }
} 

inline void solve1()
{    
    memset(head,-1,sizeof(head));    
    for(int i=1,u,v,val;i<=m;i++)    
    {    
        u=read();v=read();val=read();    
        add(u,v,val);add(v,u,val);    
    }    
    for(int i=1;i<=n;i++)    
    {    
        if(!dfn[i])    tarjan(i,0);    
    }
} 

} 

namespace LP
{ 

inline void Add(int u,int v,int val)
{    
    e[++cnt].v=v;    
    e[cnt].val=val;    
    e[cnt].next=head2[u];    
    head2[u]=cnt;
} 

void dfs1(int u,int fa)
{    
    for(int i=head2[u];i!=-1;i=e[i].next)    
    {    
        int v=e[i].v;    
        if(v==fa)    continue;    
        dis[v]=dis[u]+e[i].val;    
        if(dis[v]>mx)    mx=dis[v],root=v;    
        dfs1(v,u);    
    }
} 

void dfs2(int u,int fa)
{    
    for(int i=head2[u];i!=-1;i=e[i].next)    
    {    
        int v=e[i].v;    
        if(v==fa)    continue;    
        dis1[v]=dis1[u]+e[i].val;    
        dfs2(v,u);    
    }
} 

inline void solve2()
{    
    cnt=0;    
    memset(head2,-1,sizeof(head2));    
    for(int i=1;i<=n;i++)    
        for(int j=head[i];j!=-1;j=edge[j].next)    
        {    
            if(belong[i]!=belong[edge[j].v])    
                Add(belong[i],belong[edge[j].v],edge[j].val);    
        }    
    dfs1(1,-1);    
    mx=0;memset(dis,0,sizeof(dis));    
    dfs1(root,-1);    
    mx=0;    
    dfs2(root,-1);    
    for(int i=1;i<=n;i++)    
        printf("%d
",max(dis[belong[i]],dis1[belong[i]]));
} 
    
}
int main()
{    
    freopen("prize.in","r",stdin);
    freopen("prize.out","w",stdout);
    n=read();m=read();    
    Tarjan::solve1();    
    LP::solve2();    
    return 0;
}