D - Silver Cow Party

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

Hint

Cow 4 proceeds directly to the party (3 units) and returns via farms 1 and 3 (7 units), for a total of 10 time units.

一点思考

因为题目中要求来回最大的最短距离，一开始以为要用弗洛伊德，但是看到数据大小会超时，去看了一下题解，很巧妙的解决了这个问题。
可以用两个数组ma、ma2来存储每两个农场间的距离，ma存题目中输入的距离，ma2用来存正好相反的距离，如ma中存ma[a][b]=c,则在ma2中存ma2[b][a]=c，这样我们可以用ma数组来算出从x农场回到每个农场的最短距离，可以用ma2数组来算出从每个农场到x农场的最短距离。
也许会有到达不了的农场，所以我们遍历找最大的最短距离时需要判断距离是否小于inf。

看了一位大佬的题解：https://blog.csdn.net/qq_25425023/article/details/45532653

代码

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;

const int inf=0x3f3f3f3f;

int ma[1005][1005];//返回的距离
int ma2[1005][1005];//出发的距离
int dis[1005];
int sum[1005];//来回的距离总和
bool vis[1005];
int n,m,x;
void Dijk()
{
	for(int i=0;i<n-1;i++)//遍历除了n本身以外的n-1个城市
	{
		int min=inf,k;//用来存储最小的且没被松弛过的城市
		for(int j=1;j<=n;j++)
		{
			if(min>dis[j]&&!vis[j]) //依次比较
			{
				min=dis[j];
				k=j;//记录最小且没被松弛过的城市的下标
			}
		}
		vis[k]=1;//标记被松弛过的城市
		for(int h=1;h<=n;h++)
		{
			if(dis[h]>dis[k]+ma[k][h])
				dis[h]=dis[k]+ma[k][h];
		}
	}	
}
void Dijk2()
{
	for(int i=0;i<n-1;i++)//遍历除了n本身以外的n-1个城市
	{
		int min=inf,k;//用来存储最小的且没被松弛过的城市
		for(int j=1;j<=n;j++)
		{
			if(min>dis[j]&&!vis[j]) //依次比较
			{
				min=dis[j];
				k=j;//记录最小且没被松弛过的城市的下标
			}
		}
		vis[k]=1;//标记被松弛过的城市
		for(int h=1;h<=n;h++)
		{
			if(dis[h]>dis[k]+ma2[k][h])
				dis[h]=dis[k]+ma2[k][h];
		}
	}	
}

int main()
{
	int a,b,c;
	scanf("%d%d%d",&n,&m,&x);
	memset(ma,inf,sizeof ma);
	memset(ma2,inf,sizeof ma2);
	for(int i=1;i<=n;i++)
	{
		ma[i][i]=0;
		ma2[i][i]=0;
	}
	
	for(int i=0;i<m;i++)
	{
		scanf("%d%d%d",&a,&b,&c);
		if(c<ma[a][b])
			ma[a][b]=c;//单向道路 
		if(c<ma2[b][a])
			ma2[b][a]=c;
	}
	for(int i=1;i<=n;i++)
		dis[i]=ma[x][i];
	memset(vis,0,sizeof vis);
	vis[x]=1;
	Dijk();
	for(int i=1;i<=n;i++)
		sum[i]=dis[i];
		
	for(int i=1;i<=n;i++)
		dis[i]=ma2[x][i];
	memset(vis,0,sizeof vis);
	vis[x]=1;
	Dijk2();
	for(int i=1;i<=n;i++)
		sum[i]+=dis[i];
	int ans=-10000;
	for(int i=1;i<=n;i++)
	{
		if(sum[i]<inf)
		{
			ans=max(ans,sum[i]);
		}
	}
	printf("%d\n",ans);
	return 0;
}

第一次求x到其他点的最短距离，第二次反向存储ma数组，再求一次x到其他点的最短距离，求和找最小

排除无法到达的情况

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int INF = 0x3f3f3f3f, N = 1005;

int ma[N][N];
int dis[N], sum[N];
bool vis[N];
int n, m, x, st, ed;

void init()
{
	// 初始化ma数组
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= n; j++)
			ma[i][j] = (i == j ? 0 : INF);
}

void Dijk()
{
	for (int i = 0; i < n - 1; i++){
		int minv = INF, k; // k用来存储最小的且没被松弛过的城市
		for (int j = 1; j <= n; j++){
			if (minv > dis[j] && !vis[j]){
				minv = dis[j];
				k = j;
			}
		}
		vis[k] = 1;
		for (int h = 1; h <= n; h++)
			dis[h] = min(dis[h], dis[k] + ma[k][h]);
	}	
}

int main(void)
{
	int a, b, c;
	cin >> n >> m >> x;
	// 初始化ma数组 
	init();
	for (int i = 0; i < m; i++){
		cin >> a >> b >> c;
		if (ma[a][b] > c)
			ma[a][b] = c;
	}
	// 输入起点和终点 
	st = x;
	// 初始化dis数组
	for (int i = 1; i <= n; i++)
		dis[i] = ma[st][i];
	// 初始化vis数组
	memset(vis, 0, sizeof vis);
	vis[st] = 1;
	
	Dijk();
	memcpy(sum, dis, sizeof dis);
	
	int t;
	for (int i = 1; i <= n; i++){
		for (int j = i + 1; j <= n; j++) {
			t = ma[i][j];
			ma[i][j] = ma[j][i];
			ma[j][i] = t;	
		}
	}
	// 输入起点和终点 
	st = x;
	// 初始化dis数组
	for (int i = 1; i <= n; i++)
		dis[i] = ma[st][i];
	// 初始化vis数组
	memset(vis, 0, sizeof vis);
	vis[st] = 1;
	
	Dijk();
	int res = 0, val;
	for (int i = 1; i <= n; i++) {
		val = sum[i] + dis[i];
		// 排除到不了的城市 
		if (val < INF)
			res = max(res, val);
	}
	printf("%d\n", res);
	
	return 0;
}