图论相关算法

转载自：http://cojs.tk/cogs/page/page.php?aid=30

• 最小生成树
  • Kruskal+ufs

  •  1 int ufs(int x) {
     2        return f[x] == x ? x : f[x] = ufs(f[x]); } int Kruskal() {
     3        int w = 0;
     4        for(int i=0; i<n; i++)
     5            f[i] = i;
     6        sort(e, e+n);
     7        for(int i=0; i<n; i++) {
     8            int x = ufs(e[i].u), y = ufs(e[i].v);
     9            if(x != y) {
    10                f[x] = y;
    11                w += e[i].w;
    12            }
    13        } return w; }

  • Prim

     1 int Prim() {
     2        int w = 0;
     3        priority_queue<pair<int, int> > q;
     4        bool l[N] = {0};
     5        l[1] = 1; q.push(make_pair(0, 1));
     6        for(int k=1; k<n; k++) {
     7            int u = q.top().second; q.pop();
     8            for(int i=0; i<G[u].size(); i++)
     9                if(!l[G[u][i]])
    10                    q.push(make_pair(-c[u][i], G[u][i]));
    11            while(!q.empty() && l[q.top().second])
    12                q.pop();
    13            l[q.top().second] = 1;
    14            w += -q.top().first;
    15            q.pop();
    16        } return w; }

• 最短路径
•  Dijkstra+priority_queue

   1 void Dijkstra(int s) {
   2        priority_queue<pair<int, int> > q;
   3        bool l[N] = {0}; l[s] = 1;
   4        fill_n(f, n, INF); f[s] = 0;
   5        q.push(make_pair(-f[s], s));
   6        while(!q.empty()) {
   7            int u = q.front().second; q.pop();
   8            for(int i=0; i<G[u].size(); i++) {
   9                int v = G[u][i];
  10                if(f[v] > f[u] + c[u][i]) {
  11                    f[v] = f[u] + c[u][i];
  12                    if(!l[v]) {
  13                        l[v] = 1;
  14                        q.push(make_pair(-f[v], v));
  15                    }
  16                }
  17            }
  18        } }

• Bellman-Ford (SPFA)

   1 void BellmanFord(int s) { // SPFA
   2        queue<int> q;
   3        bool l[N] = {0}; l[s] = 1;
   4        fill_n(f, n, INF); f[s] = 0;
   5        q.push(s);
   6        while(!q.empty()) {
   7            int u = q.front(); q.pop();
   8            l[u] = 0;
   9            for(int i=0; i<G[u].size(); i++) {
  10                int v = G[u][i];
  11                if(f[v] > f[u] + c[u][i]) {
  12                    f[v] = f[u] + c[u][i];
  13                    if(!l[v]) {
  14                        l[v] = 1;
  15                        q.push(v);
  16                    }
  17                }
  18            }
  19        } }

• Floyd

  1 void Floyd() {
  2        for(int k=0; k<n; k++)
  3            for(int i=0; i<n; i++)
  4                for(int j=0; j<n; j++)
  5                    f[i][j] = min(f[i][j], f[i][k] + f[k][j]); }

• 二分图
• ufs 验证 Hungary

   1 bool DFS(int u) {
   2        for(int i=0; i<G[u].size(); i++) {
   3            int v = G[u][i];
   4            if(!l[v]) {
   5                l[v] = 1;
   6                if(!f[v] || DFS(f[v])) {
   7                    f[v] = u;
   8                    return true;
   9                }
  10            }
  11        } return false; } int Hungary() {
  12        int w = 0;
  13        for(int i=0; i<n; i++) {
  14            fill_n(l, l+n, 0);
  15            if(DFS(i))
  16                w++;
  17        } return w; }

• 连通分量
• Tarjan stack

   1 <int> s; void Tarjan(int u) {
   2        dfn[u] = low[u] = ++time;
   3        l[u] = 1;
   4        s.push(u);
   5        for(int i=0; i<G[u].size(); i++) {
   6            int v = G[u][i];
   7            if(!dfn[v]) {
   8                Tarjan(v);
   9                low[u] = min(low[u], low[v]);
  10            } else if(l[v])
  11                low[u] = min(low[u], dfn[v]);
  12        }
  13        if(dfn[u] == low[u]) {
  14            w++;
  15            do {int v;
  16                l[v = s.top()] = 0;
  17                f[v] = w;
  18                s.pop();
  19            } while(u != v);
  20        } } void SCC() {
  21        fill_n(dfn, n, 0);
  22        for(int i=0; i<n; i++)
  23            if(!dfn(i))
  24                Tarjan(i); }

• 网络流
• 费用流：Bellman-Ford 找增广路，或者用贪心求解
• 最大流：Edmonds-Karp