SGU 185 Two shortest (最大流)

题目：

http://acm.sgu.ru/problem.php?contest=0&problem=185

题意：

给你一个无向图，让你找两条不相交的从1到n的最短路径，并输出

注意：

卡内存，需要用short存数据，否则MLE

方法：

首先从1跑最短路

然后用最大流判是否两条不相交的最短路

然后用dfs输出路径

建图：

从源点向起点1建边$(S,u,2)$，表示流两条路径

从1跑完最短路后，对于任意顶点u,v，如果$d[u]+g[u][v]==d[v]$，则建边$(u,v,1)$，表示边$(u,v)$只能用一次

void build()
{
    spfa(1);
    dinic.init(n + 2);
    dinic.st = 0;
    dinic.ed = n;
    dinic.adde(dinic.st, 1, 2);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            if (d[i] + g[i][j] == d[j])
                dinic.adde(i, j, 1);
}

然后从S到顶点n跑最大流，如果流量为2，则有解，否则无解

打印路径：

从顶点1开始dfs，如果此边流满且未标记，则输出顶点，并标记此边

做两次上述打印路径的过程

void dfsout(int u)
{
    if (u == ed)
    {
        printf("%d
", u);
        return;
    }
    printf("%d ", u);
    for (int i = head[u]; ~i; i = edge[i].next)
    {
        if (i & 1) continue;
        if (edge[i].cap == edge[i].flow)
        {
            edge[i].cap++;
            dfsout(edge[i].v);
            break;
        }
    }
}

void solve()
{
    build();
    if (d[n] == inf || dinic.Dinic(inf) != 2)
    {
        puts("No solution");
        return;
    }
    dinic.dfsout(1);
    dinic.dfsout(1);
}

代码：

/********************************************
*ACM Solutions
*
*@Title: SGU 185 Two shortest
*@Version: 1.0
*@Time: 2014-08-28
*@Solution: http://www.cnblogs.com/xysmlx/p/xxxxxxx.html
*
*@Author: xysmlx(Lingxiao Ma)
*@Blog: http://www.cnblogs.com/xysmlx
*@EMail: xysmlx@163.com
*
*Copyright (C) 2011-2015 xysmlx(Lingxiao Ma)
********************************************/
// #pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <iostream>
#include <cstring>
#include <string>
#include <cmath>
#include <set>
#include <list>
#include <map>
#include <iterator>
#include <cstdlib>
#include <vector>
#include <queue>
#include <stack>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long LL;
#define pb push_back
#define ROUND(x) round(x)
#define FLOOR(x) floor(x)
#define CEIL(x) ceil(x)
const int maxn = 510;
const int maxm = 200010;
const short inf16 = 0x3f3f;
const int inf = 0x3f3f3f3f;
const LL inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double INF = 1e30;
const double eps = 1e-6;
const int P[4] = {0, 0, -1, 1};
const int Q[4] = {1, -1, 0, 0};
const int PP[8] = { -1, -1, -1, 0, 0, 1, 1, 1};
const int QQ[8] = { -1, 0, 1, -1, 1, -1, 0, 1};

short g[maxn][maxn];
int n, m;
int d[maxn];
bool spfa(int s)
{
    bool mark[maxn];
    queue<int> Q;
    memset(d, 0x3f, sizeof(d));
    memset(mark, 0, sizeof(mark));
    d[s] = 0;
    Q.push(s);
    mark[s] = 1;
    while (Q.size())
    {
        int u = Q.front();
        Q.pop();
        mark[u] = 0;
        for (int v = 1; v <= n; v++)
        {
            int w = g[u][v];
            if (w >= inf16) continue;
            if (d[u] + w < d[v])
            {
                d[v] = d[u] + w;
                if (mark[v] == 0)
                {
                    mark[v] = 1;
                    Q.push(v);
                }
            }
        }
    }
    return true;
}

struct DINIC
{
    struct Edge
    {
        int u, v;
        short cap, flow;
        int next;
    } edge[maxm];
    int head[maxn], en; //需初始化
    int n, m, d[maxn], cur[maxn];
    int st, ed;
    bool vis[maxn];
    void init(int _n = 0)
    {
        n = _n;
        memset(head, -1, sizeof(head));
        en = 0;
    }
    void addse(int u, int v, int cap, int flow)
    {
        edge[en].u = u;
        edge[en].v = v;
        edge[en].cap = cap;
        edge[en].flow = flow;
        edge[en].next = head[u];
        head[u] = en++;
        cur[u] = head[u];
    }
    void adde(int u, int v, int cap)
    {
        addse(u, v, cap, 0);
        addse(v, u, 0, 0); //注意加反向0 边
    }
    bool BFS()
    {
        queue<int> Q;
        memset(vis, 0, sizeof(vis));
        Q.push(st);
        d[st] = 0;
        vis[st] = 1;
        while (!Q.empty())
        {
            int u = Q.front();
            Q.pop();
            for (int i = head[u]; i != -1; i = edge[i].next)
            {
                int v = edge[i].v;
                int w = edge[i].cap - edge[i].flow;
                if (w > 0 && !vis[v])
                {
                    vis[v] = 1;
                    Q.push(v);
                    d[v] = d[u] + 1;
                    if (v == ed) return 1;
                }
            }
        }
        return false;
    }
    int Aug(int u, int a)
    {
        if (u == ed) return a;
        int aug = 0, delta;
        for (int &i = cur[u]; i != -1; i = edge[i].next)
        {
            int v = edge[i].v;
            int w = edge[i].cap - edge[i].flow;
            if (w > 0 && d[v] == d[u] + 1)
            {
                delta = Aug(v, min(a, w));
                if (delta)
                {
                    edge[i].flow += delta;
                    edge[i ^ 1].flow -= delta;
                    aug += delta;
                    if (!(a -= delta)) break;
                }
            }
        }
        if (!aug) d[u] = -1;
        return aug;
    }
    int Dinic(int NdFlow)
    {
        int flow = 0;
        while (BFS())
        {
            memcpy(cur, head, sizeof(int) * (n + 1));
            flow += Aug(st, inf);
            /*如果超过指定流量就return 掉*/
            if (NdFlow == inf) continue;
            if (flow > NdFlow) break;
        }
        return flow;
    }

    void dfsout(int u)
    {
        if (u == ed)
        {
            printf("%d
", u);
            return;
        }
        printf("%d ", u);
        for (int i = head[u]; ~i; i = edge[i].next)
        {
            if (i & 1) continue;
            if (edge[i].cap == edge[i].flow)
            {
                edge[i].cap++;
                dfsout(edge[i].v);
                break;
            }
        }
    }
} dinic;

int kase;
void init()
{
    kase++;
    memset(g, 0x3f, sizeof(g));
}
void input()
{
    for (int i = 0; i < m; i++)
    {
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        g[u][v] = g[v][u] = w;
    }
}
void debug()
{
    //
}
void build()
{
    spfa(1);
    dinic.init(n + 2);
    dinic.st = 0;
    dinic.ed = n;
    dinic.adde(dinic.st, 1, 2);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            if (d[i] + g[i][j] == d[j])
                dinic.adde(i, j, 1);
}
void solve()
{
    build();
    if (d[n] == inf || dinic.Dinic(inf) != 2)
    {
        puts("No solution");
        return;
    }
    dinic.dfsout(1);
    dinic.dfsout(1);
}
void output()
{
    //
}
int main()
{
    // int size = 256 << 20; // 256MB
    // char *p = (char *)malloc(size) + size;
    // __asm__("movl %0, %%esp
" :: "r"(p));

    // std::ios_base::sync_with_stdio(false);
#ifdef xysmlx
    freopen("in.cpp", "r", stdin);
#endif

    kase = 0;
    while (~scanf("%d%d", &n, &m))
    {
        init();
        input();
        solve();
        output();
    }
    return 0;
}