Silver Cow Party poj 3268 Dijkstra,spfa,+vector

Silver Cow Party poj 3268

Time Limit: 2000MS        Memory Limit: 65536K
Total Submissions: 17173        Accepted: 7845
Description
One cow from each of N farms (1 ≤ N ≤ 1000) conveniently numbered 1..N is going to attend
the big cow party to be held at farm #X (1 ≤ X ≤ N). A total of M (1 ≤ M ≤ 100,000)
unidirectional (one-way roads connects pairs of farms; road i requires Ti (1 ≤ Ti ≤ 100) units
of time to traverse.
Each cow must walk to the party and, when the party is over, return to her farm. Each cow is lazy
and thus picks an optimal route with the shortest time. A cow's return route might be different from
 her original route to the party since roads are one-way.
Of all the cows, what is the longest amount of time a cow must spend walking to the party and back?
Input
Line 1: Three space-separated integers, respectively: N, M, and X
Lines 2..M+1: Line i+1 describes road i with three space-separated integers: Ai, Bi, and Ti.
The described road runs from farm Ai to farm Bi, requiring Ti time units to traverse.
Output
Line 1: One integer: the maximum of time any one cow must walk.

Sample Input
4 8 2
1 2 4
1 3 2
1 4 7
2 1 1
2 3 5
3 1 2
3 4 4
4 2 3
Sample Output
10

正反两次最短路径，求两次最短路径和的最大值

Dijkstra

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
#define inf 0x3f3f3f3f
int dist1[1001];
int dist2[1001];
int used[1001];
int g[1001][1001];
int n,m,t;
int add_edge(int a,int b,int c)
{
	g[a][b] = c;
}
void Dijkstra(int dist[1001])
{
	memset(used,0,sizeof(used));
	int i;
	for(i=1;i<=n;i++)
	{
		dist[i] = g[t][i];
	}
	used[t] = 1;
	while(1)
	{
		int i,v,u=-1,min=inf;
		for(i=1;i<=n;i++)
		{
			if(!used[i] && min>dist[i])
			{
				min = dist[i];
				u = i;
			}
		}
		if(u==-1)
		{
			break;
		}
		used[u] = 1;
		for(v=1;v<=n;v++)
		{
			if(!used[v] && dist[v]>dist[u]+g[u][v])
			{
				dist[v] = dist[u] + g[u][v];
			}
		}
	}
}
void tran()
{
	int i,j;
	for(i=1;i<=n;i++)
	{
		for(j=1;j<=i;j++)
		{
			swap(g[i][j],g[j][i]);
		}
	}
}
int main()
{
	while(scanf("%d%d%d",&n,&m,&t)!=EOF)
	{
		int i,j,u,v,w;
		memset(g,inf,sizeof(g));
		for(i=1;i<=m;i++)
		{
			scanf("%d%d%d",&u,&v,&w);
			add_edge(u,v,w);
		}
		Dijkstra(dist1);
		tran();
		Dijkstra(dist2);
		int max = -inf;
		for(i=1;i<=n;i++)
		{
			if(dist1[i]!=inf && dist2[i]!=inf)
			{
				if(dist1[i]+dist2[i]>max)
				{
					max = dist1[i]+dist2[i];
				}
			}
		}
		printf("%d\n",max);
	}
	return 0;
}

spfa

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <queue>
using namespace std;
#define inf 0x3f3f3f3f
int dist1[1001];
int dist2[1001];
bool used[1001];
int g[1001][1001];
int n,m,t;
void Spfa(int *dist)
{
	queue<int>Q;
    memset(used,false,sizeof(used));
    memset(dist+1,inf,sizeof(int)*n);
    dist[t] = 0;
    Q.push(t); 
    used[t] = true;
    while(!Q.empty())
	{
        int u = Q.front();
        Q.pop();
        used[u] = false;
        for(int v = 1; v <= n; v++)
		{
            if(dist[u] + g[u][v] < dist[v])
			{
                dist[v] = dist[u] + g[u][v];
                if(used[v] == false)
				{
                    Q.push(v);
                    used[v] = true;
                }
            }
        }
    }
}
void tran()
{
	int i,j;
	for(i=1;i<=n;i++)
	{
		for(j=1;j<=i;j++)
		{
			swap(g[i][j],g[j][i]);
		}
	}
}
int main()
{
	while(scanf("%d%d%d",&n,&m,&t)!=EOF)
	{
		int i,j,u,v,w;
		memset(g,inf,sizeof(g));
		for(i=1;i<=m;i++)
		{
			scanf("%d%d%d",&u,&v,&w);
			g[u][v] = w;
		}
		Spfa(dist1);
		tran();	
		Spfa(dist2);
		int max = - inf;
		for(i=1;i<=n;i++)
		{
			if(dist1[i]!=inf && dist2[i]!=inf)
			{
				if(dist1[i]+dist2[i]>max)
				{
					max = dist1[i]+dist2[i];
				}
			}
		}
		printf("%d\n",max);
	}
	return 0;
}

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <vector>
using namespace std;
#define inf 0x3f3f3f3f
int n,m,x;
struct Node
{
	int v;
	int w;
}edge;
vector<Node>map1[1001];
vector<Node>map2[1001];
int dist1[1001];
int dist2[1001];
bool vis[1001];
void add_edge1(int a,int b,int c)
{
	edge.v = b;
	edge.w = c;
	map1[a].push_back(edge);
}
void add_edge2(int a,int b,int c)
{
	edge.v = b;
	edge.w = c;
	map2[a].push_back(edge);
}
void init()
{
	memset(vis,false,sizeof(vis));
	memset(dist1,0x3f,sizeof(dist1));
}
void Dijkstra()
{
	init();
	dist1[x] = 0;
	while(1)
	{
		int u = -1,i,j,v,min=inf;
		for(i=1;i<=n;i++)
		{
			if(!vis[i] && min>dist1[i])
			{
				min = dist1[i];
				u = i;
			}
		}
		if(u==-1)
		{
			break;
		}
		vis[u] = true;
		for(j=0;j<map1[u].size();j++)
		{
			int v = map1[u][j].v;
			int w = map1[u][j].w;
			if(!vis[v] && dist1[v] > dist1[u] + w)
			{
				dist1[v] = dist1[u] + w;
			}
		}
	}
}
int main()
{
	while(scanf("%d%d%d",&n,&m,&x)!=EOF)
	{
		int i,j;
		int a,b,c;
		for(i=1;i<=m;i++)
		{
			scanf("%d%d%d",&a,&b,&c);
			add_edge1(a,b,c);
			add_edge2(b,a,c);
		}
		Dijkstra();
		memcpy(dist2,dist1,sizeof(dist1));
		for(i=1;i<=n;i++)
		{
			map1[i] = map2[i];
		}
		Dijkstra();
		int max = - inf;
		for(i=1;i<=n;i++)
		{
			if(dist1[i]!=inf && dist2[i]!=inf)
			{
				if(max<dist1[i]+dist2[i])
				{
					max = dist1[i] + dist2[i];
				}
			}
		}
		printf("%d\n",max);
		for(i=1;i<=n;i++)
		{
			map1[i].clear();
			map2[i].clear();
		}			
	}
	return 0;
}