HDU3072

题意：

　　给出n个点(0 - n-1)，m条边，code从0开始需要传播到1 - (n-1)的每个点，强连通分量之间的传播是没有花费的，求最小花费。

思路：

　　缩点，遍历边集，维护两端不属于一个连通分量的边的权和。

#include <bits/stdc++.h>

const int MAXN = 50000+10;
const int MAXM = 100000+10;
const int INF = 0x3f3f3f3f;
 
struct Edge
{
    int v, cost, next;
    Edge() {}
    Edge(int _v, int _cost, int _next):v(_v), cost(_cost), next(_next){}
} edge[MAXM];
int tot;

int g[MAXN], dfn[MAXN], low[MAXN], T,ind,id[MAXN],dist[MAXN];

bool vis[MAXN];
std::stack<int> sta;

void add_edge(int u, int v, int cost)
{
    edge[tot] = Edge(v,cost,g[u]);
    g[u] = tot++;
}

void tarjan(int u)
{
    sta.push(u);
    vis[u] = true;
    dfn[u] = low[u] = T++;
    for(int i = g[u]; i != -1; i = edge[i].next) {
        int v = edge[i].v;
        if(!dfn[v]) {
            tarjan(v);
            low[u] = std::min(low[u], low[v]);
        }
        else if(vis[v] && low[u] > dfn[v]) 
            low[u] = dfn[v];
    }
    if(low[u] == dfn[u]) {
        ind++;
        int v;
        do {
            v=sta.top();
            sta.pop();
            id[v] = ind;
            vis[v] = false;
        }while(v != u);
    }
}
 
void init()
{
    memset(g, -1, sizeof g);
    memset(vis, 0, sizeof vis);
    memset(dfn,0, sizeof dfn);
    memset(low,0,sizeof low);
    T = ind = tot = 0;
    while(sta.empty() == false) 
        sta.pop();
}

int main()
{
    int n, m;
    while(~scanf("%d%d", &n, &m) ){
        init();
        for(int i = 0, a, b, c; i<m; i++) {
            scanf("%d%d%d", &a, &b, &c);
            add_edge(a,b,c);
        }

        // get all strongly connected component
        // and color them
        for(int i = 0; i < n; ++ i){
            if(dfn[i] == false){
                tarjan(i);
            }
        }
        // dist[i] is the minimum distance between i and any other point
        for(int i = 0; i < ind; i++) {
            dist[i] = INF;
        }
        for(int i = 0; i < n; i++) {
            int u = id[i];
            for(int e = g[i]; e != -1; e = edge[e].next) {
                int v = id[edge[e].v];
                if(u != v) {
                    dist[v] = std::min(dist[v], edge[e].cost);
                }
            }
        }

        int res = 0;
        for(int i = 0; i < ind; ++ i) {
            if(i == id[0] || dist[i] == INF)
                continue;
            res += dist[i];
        }
        printf("%d
", res);
    }
    return 0;
}