【最大流】Sgu 185 _ Two shortest

为了这题我都快wa傻了，简述几点

1.鄙视卡内存的题目

2.鄙视卡内存还卡时间的题目

这题我本来是的思路是求一次最短路，删除这条路上的边，然后再求一次最短路，后来我举了一个例子，将这个方法否定掉了

如果我们按照红色的路径删除最短路，就破坏了另一条最短路。

因此我们换了一个思路，那就是求最大流。

方法是：先求一次最短路，然后将最短路树上的每一条边都加入到一个新的图中，将流量设为1，费用就是边长，建立一个新的图，然后求两次最小费用最大流。

理论上的基础是：

1.最短路树上能到达终点的路径一定是最短路。

2.所有边流量都是1，所以最大流一定不相交。

//sevenkplus bless me
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<stdlib.h>
#include<cctype>
#include<cmath>
#include<limits.h>
#include<iomanip>
#include<cstring>
#include<fstream>
#include<string>
#include<queue>
#include<stack>
#include<set>
#include<map>
#include<vector>
using namespace std;
const double pi = 4.0 * atan(1.0);
typedef signed long long LL;
#define clr(x) memset(x,0,sizeof(x))
#define clro(x) memset(x,-1,sizeof(x))
typedef pair<int,int> pii;
const int inf = 9999999;
#define sf scanf
#define pf printf
const int maxn = 500;
const int maxm = 160004;
bool vis[maxn];
int dis[maxn];
int w[maxn][maxn];
struct Edge{ short from,to,cap,len; };
Edge edges[maxm];
int head[maxn];
int next[maxm];
int pre[maxn];
int tot,deep;
queue<short>que;
bool spfaa( short s,short t){
    int i;
    short u,v;
    if( t <= 2 ) return false;
    clr(vis);
    for( i=0; i<maxn; ++i) dis[i] = inf;
    dis[s] = 0;
    que.push(s);
    while( !que.empty() ){
        u = que.front(); que.pop();
        vis[u] = false;
        for( v=0; v<maxn; ++v){
            if( dis[u] + w[u][v] < dis[v] ){
                dis[v] = w[u][v] + dis[u];
                if( !vis[v] ){
                    vis[v] = true;
                    que.push(v);
                }
            }
        }
    }
    if( dis[t] == inf ) return false;
    return true;
}
void addedge( short from, short to, int len){
    Edge z;
    z.from = from, z.to = to, z.cap = 1, z.len = len;
    edges[tot] = z;
    next[tot] = head[from];
    head[from] = tot++;
    z.from = to, z.to = from, z.cap = 0, z.len = len;
    edges[tot] = z;
    next[tot] = head[to];
    head[to] = tot++;
}
bool spfa( int s,int t){
    int i;
    clr(vis);
    queue<short>que;
    for( i=0; i<maxn; ++i) dis[i] = inf;
    dis[s] = 0;
    que.push(s);
    while( !que.empty() ){
        short u = que.front(); que.pop();
        vis[u] = false;
        for( i=head[u]; ~i; i = next[i]){
            Edge &e = edges[i];
            if( e.cap > 0 && dis[u] + e.len < dis[e.to] ){
                pre[e.to] = i;
                dis[e.to] = e.len+ dis[u];
                if( !vis[e.to] ){
                    vis[e.to] = true;
                    que.push(e.to);
                }
            }
        }
    }
    if( dis[t] == inf ) return false;
    return true;
}
int fl;
int N;
void dfs(int u, int f) {
    if (fl) return ;
    pre[u] = f;
    if (u == N) {
        fl = true;
        return ;
    }
    for (int i = head[u]; ~i; i = next[i]) {
        if (fl) return ;
        if ((i & 1) == 0 && edges[i].cap == 0) {
            edges[i].cap = -1;
            dfs(edges[i].to, u);
        }
    }

}

void print(int s, int t) {
    int rec[maxn];
    fl = false;
    dfs(s, -1);
    int k = 0;
    for (int u = t; ~u; u = pre[u]) {
        rec[k++] = u;
    }
    for (int i = k - 1; i >= 0; --i) {
        if (i < k - 1) putchar(' ');
        printf("%d", rec[i]);
    }
    printf("\n");
}
void path( int s, int t){
    for( int u = t; u != s; u = edges[pre[u] ].from){
        edges[pre[u] ].cap -= 1;
        edges[pre[u]^1 ].cap += 1;
    }
}
int maxflow( int s, int t){
    int f = 0;
    while( spfa(s,t) ){
        path(s,t);
        if( ++f ==  2 ) return f;
    }
    return f;
}
void init(){
    clro(head);
    for( int i=0; i<maxn; ++i)
        for( int j=0; j<maxn; ++j)
            w[i][j] = inf;
    tot = 0;
}
bool doit(int n, int m){
    N = n;
    int a,b,c;
    init();
    for( int i=0; i<m; ++i){
        sf("%d%d%d",&a,&b,&c);
        w[a][b] = min( w[a][b], c);
        w[b][a] = w[a][b];
    }
    if( !spfaa(1,n) ){
        puts("No solution");
        return false;
    }
    for( int i=0; i<maxn; ++i){
        for( int j=0; j<maxn; ++j){
            if( w[i][j] + dis[i] == dis[j] )
                addedge(i,j,w[i][j]);
        }
    }
    return true;
}
int main(){
    int n,m;
    sf("%d%d",&n,&m);
    if( doit(n,m) ){
        //cout<<fff.maxflow(1,n)<<endl;
        if( maxflow(1,n) < 2 ){
            puts("No solution");
            return 0;
        }
    }
    print(1,n);
    print(1,n);
    return 0;
}