sgu 185 Two shortest

求两条最短路，输出路径。

直接先跑一遍最短路，然后按照 dis[i] + a[i][k] == dis[k] 建立网络流的边，容量为1。

然后跑一遍汇点容量为2的最大流。也就是求得了两条路。

然后从原点DFS正向边，DFS一条路径后删掉这条路径，DFS2次，就求得了两条这样的边，输出即可。

用的党的sap模板，他的dinic模板TLE了，让我帮他打广告，FOOKWOOD.COM

#include <set>
#include <map>
#include <queue>
#include <stack>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <limits.h>
#include <string.h>
#include <string>
#include <algorithm>
#define MID(x,y) ( ( x + y ) >> 1 )
#define L(x) ( x << 1 )
#define R(x) ( x << 1 | 1 )
#define FOR(i,s,t) for(int i=s; i<t; i++)
#define BUG puts("here!!!")
#define STOP system("pause")

using namespace std;

const int MAX = 402;
const int INF = 2100000000;
const short MMAX = 11000;
short a[MAX][MAX];
class Arc{
public:
    short to,w,pre;
    Arc *next,*anti;
    Arc *ass( int tt,int ww,Arc* &b ){
        to = tt;w = ww;next = b;b = this;return this;
    }
};
short min(short a,short b)
{
	return a < b ? a : b;
}
template< int Vsize, int Esize >
class Network{
private:
    Arc A[ 2*Esize+2 ],*biao[ Vsize ];
    int countt,d[ Vsize ],S,T,N;
public:
    Network( void ) {}
    Network( int n ) { init(n) ;}
    bool f1;
	queue<short> q;;
	void DFS(int x, int to)
	{
		if( x == to )
		{
			printf("%d\n",x);
			f1 = true;
			return ;
		}
		printf("%d ",x);
		Arc *head = biao[x];
		while( head != NULL )
		{
			if( (head-A)%2 == 0 && head->w == 0 )
			{
				head->w = 1;
				DFS(head->to, to);
				if( f1 ) return ;
			}
			head = head->next;
		}
	}
    void init( int n ){
		f1 = false;
        countt = 0;N = n;
        for( int i = 0; i <= n; i++ )
            biao[i] = NULL;
    }
    void add( int from,int to,int w ){
    	Arc *p1 = A[countt++].ass( to,w ,biao[from]);
    	Arc *p2 = A[countt++].ass( from,0,biao[ to] );
    	p1->anti = p2; p2->anti = p1;
    }
    int MaxFlowSap( int s, int t){
        S = s;T = t;
    	int i,now,total,md;
    	Arc *p,*locate,*ge[ Vsize ],*di[ Vsize ],*path[ Vsize ];
    	int dist[ Vsize ], cd[  Vsize ];
        int his[  Vsize ], pre[ Vsize ];;
    	bool flag;
    	memset( dist,0, sizeof(dist) );
    	memset( cd,  0, sizeof(cd)   );
    	cd[0] = N;
    	for( i = 0; i <= N ; i++ )
            di[i] = ge[i] = biao[i];
    	for( total = 0, now = INF,i = S; dist[i] < N; ){
    		his[i] = now;
    		for( flag = false,p=di[i]; p!=NULL; p= p->next){
    		    if( p->w > 0 && dist[i] ==dist[p->to] + 1 ){
    			now = min( now,p->w );
    			pre[ p->to ] = i;
    			path[ p->to ] = p;
    			di[i] = p;
    			i = p->to;
    			if( i == T ){
    			    for( total += now; i != S; i = pre[i] )
    				path[i]->w -= now, path[i]->anti->w += now;
    			    now = INF;
    			}
    			flag = true;
    			break;
    		    }
    		}
    		if( !flag ){
    			for( md = N-1,p=ge[i];p!= NULL;p=p->next )
    				if( p->w > 0 && dist[p->to] < md )
    					md = dist[p->to],locate = p;
    			di[i] = locate;
    			if( !(--cd[ dist[i] ] ) ) break;
    			cd[ dist[i] = md+1 ] ++;
    			if( i != S )
    				i = pre[i],now = his[i];
    		}
    	}
    	return total;
    }
};
Network<MAX,MAX*MAX/2> net;	
void Dijkstra(int n,int from,int to)
{
	int dis[MAX];
	bool used[MAX];
	memset(used,false,sizeof(used));
	for(int i=1; i<=n; i++)
		dis[i] = INT_MAX;
	dis[from] = 0;
	used[from] = true;
	int now = from;
	for(int i=1; i<n; i++)
	{
		for(int k=1; k<=n; k++)
			if( a[now][k] != MMAX && dis[now] != INT_MAX
				&& dis[k] > dis[now] + a[now][k] )
				dis[k] = dis[now] + a[now][k];		
		int min = INT_MAX;
		for(int k=1; k<=n; k++)
			if( !used[k] && dis[k] < min )
				min = dis[now = k];
		used[now] = true;
	}
	for(int i=1; i<=n; i++)
		for(int k=1; k<=n; k++)
		{
			if( i == k ) continue;
			if(	dis[i] != INT_MAX && dis[k] != INT_MAX 
				&& a[i][k] != MMAX && dis[i] + a[i][k] == dis[k] )
				net.add(i, k, 1);
		}
	net.add(n, n+1, 2);
}

int main()
{
	int n, m, u, v, l;
	
	while( ~scanf("%d%d", &n, &m) )
	{
		net.init(n+3);
		FOR(i, 0, n+1)
		{
			FOR(k, 0, n+1)
				a[i][k] = MMAX;
			a[i][i] = 0;
		}
		
		while( m-- )
		{
			scanf("%d%d%d", &u, &v, &l);
			a[u][v] = a[v][u] = l;
		}
		
		Dijkstra(n, 1, n);

		int sum = net.MaxFlowSap(1, n+1);
		if( sum != 2 )
		{
			printf("No solution\n");
			continue;
		}
		
		net.DFS(1, n);		
		net.DFS(1, n);
	}
return 0;
}