Korasaju 算法模板

  见网上都没有这个算法的具体模板，我不为什么，也许是太简单啦 在队友的帮助下，写了一个，分享一下，
追求简单易懂（不求短码） 你如果理解后，可以大大的简写代码（不用写两个dfs 一个就够了）

对应hdoj 3072

题意：给你n个点，m条边，每条边有一个权值（传送message代价），已知强连通分支内部不需花费，求minimal cost

步骤：

1.缩点n->scc个点

2.将到这scc个点的最小代价计算出来

3.相加

  #include <stdio.h>
#include <string.h>

#define INF      0x3f3f3f3f
#define V      50050
#define E      100050

struct edge
{
      int to, cost, next;
}Edge1[E], Edge2[E];  //edge1是正向图G edge2 是图G的逆GT
int head1[V], head2[V], e, n;

void addedge(int u, int v, int c)
{
      Edge1[e].to = v;
      Edge1[e].cost = c;
      Edge1[e].next = head1[u];
      head1[u] = e;
      Edge2[e].to = u;
      Edge2[e].cost = c;
      Edge2[e].next = head2[v];
      head2[v] = e++;
}

int cnt, scc;
int order[V],vis[V], scc_id[V], dist[V];
//order是记录点出栈的时间，ssc_id 记强连通分量的集合 在同一强连通分量中 ssc_id[i] 的值相同
int dfs(int u)  //搜索图G 记录各点出栈时间
{
      for (int i=head1[u]; i!=-1; i=Edge1[i].next)
      {
            int v = Edge1[i].to;
            if (vis[v] == 0)
            {
                  vis[v] = 1;
                  dfs(v);
            }
      }
      order[++cnt] = u;      //order [1..n] 记录的是出栈时间最早的 order[1]最早
      return 0;
}

int redfs(int u)  //搜索GT图 缩点
{
      for (int i=head2[u]; i!=-1; i=Edge2[i].next)
      {
            int v = Edge2[i].to;
            if (scc_id[v] == 0)
            {
                  scc_id[v] = scc;
                  redfs(v);
            }
      }
      return 0;
}

int kosaraju()
{
      int i, u;
      cnt = scc = 0;      //scc是强连通图的个数
      memset(order, 0, sizeof(order));
      memset(vis, 0, sizeof(vis));
      for (i=0; i!=n; ++i)
      {
            if (vis[i] == 0)
            {
                  vis[i] = 1;
                  dfs(i);
            }
      }
      memset(scc_id, 0, sizeof(scc_id));
      for (i=n; i!=0; --i)                    //从出栈时间最晚的开始搜索缩点 这样不会连通到别的树上
      {
            u = order[i];
            if (scc_id[u] == 0)
            {
                  scc_id[u] = ++scc;
                  redfs(u);
            }
      }
      return scc;
}

int main()
{
      int i;
      int m;
      while (~scanf("%d %d", &n, &m))
      {
            e = 0;
            memset(head1, -1, sizeof(head1));
            memset(head2, -1, sizeof(head2));
            int u, v, c;
            for (i=0; i!=m; ++i)
            {
                  scanf("%d %d %d", &u, &v, &c);
                  addedge(u, v, c);
            }
            kosaraju();
            memset(dist, 0x3f, sizeof(dist));
            for (u=0; u!=n; ++u)
            {
                  for (i=head1[u]; i!=-1; i=Edge1[i].next)
                  {
                        v = Edge1[i].to;
                        c = Edge1[i].cost;
                        if (scc_id[u] != scc_id[v])
                              dist[scc_id[v]] = dist[scc_id[v]] < c ? dist[scc_id[v]] : c;
                  }
            }
            int ans = 0;
            for (i=1; i<=scc; ++i)
            {
                  if (dist[i] == INF)
                        dist[i] = 0;
                  ans += dist[i];
            }
            printf("%d\n", ans);
      }
      return 0;
}