hdu 3072 Intelligence System （强连通，缩点）

题意：

给一个有向图，将SCC缩点后得到DAG，求一颗根为0的“有向最小生成树”，使0到其他各个顶点的费用和最小。

思路：

先kosaraju算法求SCC。

所求的“树”，是连接两个不同的连通分量的边集的子集。

于是按照连通分量的topo顺序，枚举一下即可。

//#include<bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <queue>
#include <stack>
#include <cassert>
#include <algorithm>
#include <cmath>
#include <climits>
#include <set>
#include <map>

using namespace std;

#define SPEED_UP iostream::sync_with_stdio(false);
#define FIXED_FLOAT cout.setf(ios::fixed, ios::floatfield);
#define rep(i, s, t) for(int (i)=(s);(i)<=(t);++(i))
#define urep(i, s, t) for(int (i)=(s);(i)>=(t);--(i))
#define in_bound(l, r, i) (l)<=(i)&&(i)<(r)
#define pb push_back

typedef long long LL;

struct Edge{
    int from, to, cost;
    Edge(){}
    Edge(int u, int v, int w):from(u), to(v), cost(w){}
};

const int Maxn = 50000+5;
const int MaxEdge = 100000+5;
const int inf = INT_MAX/2;

int used[Maxn], sccNo[Maxn], d[105][105], n, totEdge, m;
vector<int> g[Maxn], rg[Maxn], vs;
Edge E[MaxEdge*2];
map<pair<int, int>, int> ma;

void dfs(int now) {
    used[now] = 1;
    int sz = g[now].size(), v;
    rep(i, 0, sz-1) {
        Edge &e = E[g[now][i]];
        v = e.to;
        if (!used[v]) dfs(v);
    }
    vs.push_back(now);
}

void rdfs(int now, int flag) {
    used[now]  = 1;
    sccNo[now] = flag;
    int sz = rg[now].size(), v;
    rep(i, 0, sz-1) {
        Edge &e = E[rg[now][i]];
        v = e.to;
        if (!used[v]) rdfs(v, flag);
    }
}

int scc(int V) {
    memset(used, 0, sizeof(used));
    vs.clear();
    //rep(i, 0, V-1)
    //    if (!used[i]) dfs(i);

    urep(i, V-1, 0)
        if (!used[i]) dfs(i);

    memset(used, 0, sizeof(used));
    int cnt = 0;
    urep(i, V-1, 0)
        if (!used[vs[i]]) rdfs(vs[i], cnt++);
    return cnt;
}

void add_edge(int from, int to, int cost) {
    if (from == to) return;
    /*
    pair<int, int> tmp = make_pair(from, to);
    if (ma.count(tmp)) {
        int idx = ma[tmp];
        if (E[idx].cost > cost) {
            E[idx].cost = E[idx+m].cost = cost;
        }
        return;
    }*/
//    ma[tmp] = totEdge;
    E[totEdge] = Edge(from, to, cost);
    E[totEdge+m] = Edge(to, from, cost);
    g[from].push_back(totEdge);
    rg[to].push_back(totEdge+m);
    ++totEdge;
}

void init() {
    rep(i, 0, n-1) {
        g[i].clear();
        rg[i].clear();
    }
    ma.clear();
    totEdge = 0;
    rep(i, 0, m-1) {
        int x, y, z;
        scanf("%d%d%d",&x, &y, &z);
        add_edge(x, y, z);
    }
}

LL solve() {
    int tot = scc(n);
#if 0
    rep(i, 0, tot-1) {
        cout << "{ ";
        rep(j, 0, n-1)
            if (sccNo[j] == i) cout << j << ' ';
        cout << "}\n";
    }
#endif

    rep(i, 0, tot)
        rep(j, 0, tot) d[i][j] = inf;

    rep(i, 0, totEdge-1) {
        Edge & e = E[i];
        int u = sccNo[e.from], v = sccNo[e.to];
        if (u != v && e.cost < d[u][v]) {
            d[u][v] = e.cost;
        }
    }

    LL ans = 0;
    rep(i, 1, tot-1) {
        int _min = inf;
        rep(j, 0, i-1) _min = min(_min, d[j][i]);
        ans += _min*1ll;
    }
    return ans;
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.in", "r", stdin);
#endif
    //SPEED_UP

    while (scanf("%d%d",&n, &m) != EOF) {
        init();
        //cout << "Edges: \n";rep(i, 0, totEdge-1) cout << E[i].from << ' ' << E[i].to << ' ' << E[i].cost << endl;
        printf("%I64d\n", solve());
    }

    return 0;
}