SGU 185.Two shortest （最小费用最大流）

时间限制：0.25s

空间限制：4M

题意：

       在n（n<=400）个点的图中，找到并输出两条不想交的最短路。不存在输出“No sulotion”；

 

 

 

 

 

---

 

Solution：

            最小费用最大流

            建图与poj 2135 一样,添加S到1的流量为2权为0,n到T的流量为2权为0的边,其它边的流量为1,权为路径长度.

            但是这道题麻烦不在要输出最短路，而在仅仅4M的内存上。

            由于只有4M，我们最多存上400*400条边.但是图却是一个无向图,朴素的想法是存上400*400*2条边,但是这里内存不够.

            所以我们首先要确定记录一条边我们是否使用过,如果使用了使用的是那个方向.

            相应的在找到增广路后,把正向反向边的流量改变,把反向边的费用变成负值.

            最后按照我们标记过的边dfs,并输出就好了.

            总的来说是一道足以加深对最小费用最大流的理解的不错的题!

 

参考代码:

/*

       最小费用最大流算法：

       思路：

       以费用为权做最短路算法。

*/

#include <iostream>

#include <cstdio>

#include <queue>

#include <cstring>

#include <cmath>

using namespace std;

const int INF = 409, Maxn = 0x3f3f3f3f;



struct node {

    int u, v, t, c, next;

} edge[INF * INF];

int head[INF], nCnt = 1;

int G[INF][INF];

void addEdge (int u, int v, int traffic, int cost) {

    edge[++nCnt].v = v, edge[nCnt].u = u, edge[nCnt].t = traffic, edge[nCnt].c = cost;

    edge[nCnt].next = head[u], head[u] = nCnt;

    edge[++nCnt].v = u, edge[nCnt].u = v, edge[nCnt].t = traffic, edge[nCnt].c = cost;

    edge[nCnt].next = head[v], head[v] = nCnt;

}

int max_flow, min_cost;

int n, m, SS, ST, S, T, min_dis = Maxn;

int SPFA() {

    queue<int> ql;

    int vis[INF] = {0}, dis[INF], pre[INF] = {0};

    ql.push (SS);

    memset (dis, 0x3f, sizeof dis);

    vis[SS] = 1, dis[SS] = 0;

    while (!ql.empty() ) {

        int x = ql.front(); ql.pop();

        for (int i = head[x]; i != 0; i = edge[i].next) {

            if (edge[i].t == 0) continue;

            int v = edge[i].v, c = edge[i].c;

            if (dis[v] > dis[x] + c) {

                dis[v] = dis[x] + c;

                pre[v] = i;

                if (!vis[v])

                    ql.push (v), vis[v] = 1;

            }

        }

        vis[x] = 0;

    }

    min_dis = min (min_dis, dis[ST]);

    if (dis[ST] == Maxn) return 0;

    else {

        min_cost += dis[ST];

        int k = pre[ST];

        int cur_flow = Maxn;

        while (k) {

            if (cur_flow > edge[k].t) cur_flow = edge[k].t;

            G[edge[k].u][edge[k].v] = G[edge[k].v][edge[k].u] = 1 ^ G[edge[k].v][edge[k].u];

            edge[k].t = edge[k ^ 1].t, edge[k].c = abs (edge[k].c);

            edge[k ^ 1].t = 0, edge[k ^ 1].c = -abs (edge[k ^ 1].c);

            k = pre[edge[k].u];

        }

        max_flow += cur_flow;

        k = pre[ST];

        while (k) {

            edge[k].t -= cur_flow, edge[k ^ 1].t += cur_flow;

            k = pre[edge[k].u];

        }

        return 1;

    }

}

void dfs (int x) {

    for (int i = head[x]; i != 0; i = edge[i].next) {

        if (G[x][edge[i].v] && edge[i].t > 0 && edge[i].v < T) {

            edge[i].t = 0;

            dfs (edge[i].v);

            break;

        }

    }

    if (x == S) printf ("%d", x);

    else

        printf (" %d", x);

}

int MCMF() {

    while (SPFA() );

    if (max_flow == 2 && min_cost == 2 * min_dis) {

        dfs (T);

        putchar (10);

        dfs (T);

    }

    else

        puts ("No solution");

}

void build() {

    scanf ("%d %d", &n, &m);

    int x, y, z;

    for (int i = 1; i <= m; i++) {

        scanf ("%d %d %d", &x, &y, &z);

        addEdge (x, y, 1, z);

    }

    S = 1, T = n;

    SS = n + 1, ST = n + 2;

    addEdge (SS, S, 2, 0), addEdge (T, ST, 2, 0);

}

int main() {

    build();

    MCMF();

    return 0;

}

View Code