sgu 185(最短路+最大流)

题目链接：http://acm.sgu.ru/problem.php?contest=0&problem=185

题意：求两条不公边的最短路，存在则输出两条路径，不存在则输出No solution

经过无数的re 22，wa 20和MEL终于用最短路+最大流给A啦，感谢苍天的解救啊！刚开始用的费用流解决：建图源点到1建一条容量为2，费用为0的边，n到汇点连一条容量为2，费用为0的边，原图中的边（U,V）容量为1，费用为U--v的距离，这样建图之后，求最小费用最大流就可以判断出是否存在路径（当最大流为2，且C[0]==C[1]时存在满足题意的路径，C中存放的是第一次和第二次的最短路径的长度），用该方法开始一直wa 20 （是因为找路径的时候找错了，注意这里满足条件的路径应为费用为正，流量为0），后面就一直re 22至今未解决，老火！！！！！ 后面弃暗投明用最短路+最大流给A啦，建图的方法先求出1到所有点的最短路径，然后满足dist[u]+g[u][v]==dist[v]的建边(这样建边使得可能在最短路上的边都在新图中)，权值为1，这样建图后求最大流，若最大流>=2则表明存在这样的两条路径，否则直接输出solution！ 

注意用最大流是找路径的时候不应该满足条件的边不应该只是权值为0的边，还应该加上该边是非逆向边，因为有的逆向边的权值也为0

代码：

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;

const short N = 410;
const int inf = 0xfffffff;
const int E = 170000;
short g[N][N];
int dist[N];
int e,head[N];
int dep[N],que[N],cur[N],n;
bool tag;
struct node
{
	int x,y;
	int nxt;
	int c;
}edge[E];
void addedge(int u,int v,int c)
{
	edge[e].x=u;
	edge[e].y=v;
	edge[e].nxt=head[u];
	edge[e].c=c;
	head[u]=e++;

	edge[e].x=v;
	edge[e].y=u;
	edge[e].nxt=head[v];
	edge[e].c=0;
	head[v]=e++;
}

int maxflow(int s,int t)
{
	int i,j,k,top, front,rear,min,res=0;
	while(1)
	{
		memset(dep,-1,sizeof(dep));
		front=0;
		rear=0;
		que[rear++]=s;
		dep[s]=0;
		while(front!=rear)
		{
			i=que[front++];
			for(j=head[i];j!=-1;j=edge[j].nxt)
				if(edge[j].c&&dep[edge[j].y]==-1)
				{
					dep[edge[j].y]=dep[i]+1;
					que[rear++]=edge[j].y;
				
				}
		}
		if(dep[t]==-1)
			break;
		memcpy(cur,head,sizeof(head)); 
		for(i=s,top=0;;)
		{
			if(i==t)
			{
				min=inf;
				for(k=0;k<top;k++)
					if(min>edge[que[k]].c)
					{
						min=edge[que[k]].c;
						front=k;
					}
				for(k=0;k<top;k++)
				{
					edge[que[k]].c-=min;
					edge[que[k]^1].c+=min;
				}
				res+=min;
				i=edge[que[top=front]].x;
				
			}
			for(j=cur[i];cur[i]!=-1;j=cur[i]=edge[cur[i]].nxt)
				if(dep[edge[j].y]==dep[i]+1&&edge[j].c)
					break;
			if(cur[i]!=-1)
			{
				que[top++]=cur[i];
				i=edge[cur[i]].y;
			}
			else
			{
				if(top==0)
					break;
				dep[i]=-1;
				i=edge[que[--top]].x;
			}
		}
	}
	return res;
}
void spfa(short s,short t)
{
	short j,u; bool vis[N];
	for(j = s;j<=t;j++)
	{
		dist[j]=inf;
		vis[j]=false;
	}
	dist[s]=0;
	vis[s]=true;
	que[0]=s;
	short front=0,rail=1;
	while(front!=rail)
	{
		u = que[front];
		front =(front+1)%N;
		for(j=1;j<=t;j++)
		{
			if(g[u][j]!=-1&&dist[j] > dist[u]+g[u][j])
			{
				dist[j]=dist[u]+g[u][j];
				if(!vis[j])
				{
					vis[j]=true;
					que[rail]=j;
					rail =(rail+1)%N;
				}
			}
		}
		vis[u]=false;
	}
}

void output(short u)
{
	printf("%d ",u);
	if(u==n)
	{
		tag=false;
		return;
	}
	for(int i = head[u];i!=-1;i=edge[i].nxt)
	{
		short v = edge[i].y;
		if(edge[i].c==0&&i%2==0)//注意这里的（i%2==0）用来排除逆向边
		{
			edge[i].c=-1;
			output(v);
			return ;
		}
	}
}

int main()
{
	int m,i;
	short x, y, c,j;
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		for(i=1;i<=n;i++)
			for(j=1;j<=n;j++)	
				 g[i][j] = -1;
		for(i=0;i<m;i++)
		{
			scanf("%d%d%d",&x,&y,&c);
			g[x][y]=c;
			g[y][x]=c;
		}
		spfa(1,n);
		e = 0;
		memset(head,-1,sizeof(head));
		for(i=1;i<=n;i++)
			for(j=1;j<=n;j++)
				if(g[i][j]!=-1&&dist[i]+g[i][j]==dist[j])
					addedge(i,j,1);
		int flow = maxflow(1,n);
		if(flow>=2)
		{
			tag = 1;
			output(1);
			printf("\n");
			tag =1;
			output(1);
			printf("\n");
		}
		else printf("No solution\n");
	}
	return 0;
}