hdu 2066

Description

虽然草儿是个路痴（就是在杭电待了一年多，居然还会在校园里迷路的人，汗~),但是草儿仍然很喜欢旅行，因为在旅途中 会遇见很多人（白马王子，^0^），很多事，还能丰富自己的阅历，还可以看美丽的风景……草儿想去很多地方，她想要去东京铁塔看夜景，去威尼斯看电影，去阳明山上看海芋，去纽约纯粹看雪景，去巴黎喝咖啡写信，去北京探望孟姜女……眼看寒假就快到了，这么一大段时间，可不能浪费啊，一定要给自己好好的放个假，可是也不能荒废了训练啊，所以草儿决定在要在最短的时间去一个自己想去的地方！因为草儿的家在一个小镇上，没有火车经过，所以她只能去邻近的城市坐火车（好可怜啊~）。

Input

输入数据有多组，每组的第一行是三个整数T，S和D，表示有T条路，和草儿家相邻的城市的有S个，草儿想去的地方有D个；
接着有T行，每行有三个整数a，b，time,表示a,b城市之间的车程是time小时；(1=<(a,b)<=1000;a,b 之间可能有多条路)
接着的第T+1行有S个数，表示和草儿家相连的城市；
接着的第T+2行有D个数，表示草儿想去地方。

Output

输出草儿能去某个喜欢的城市的最短时间。

Sample Input 

6 2 3
1 3 5
1 4 7
2 8 12
3 8 4
4 9 12
9 10 2
1 2
8 9 10

Sample Output

9

刚开始还没有看迪杰斯特拉和佛洛依德，于是自己想了好久写了一个有BUG的DP思想的暴力，修到最后发现，暴力不是不可以，就是不能剪枝，因为某一个起点可能可以去到另一个起点，这时便会把另一个起点标注为无限大，即不可到达终点，所以每一个这样被标注的点都要重新去递归——结果就是内存炸了= =。

所以还是迪杰斯特拉：

#include<cstdio>
#include<cstring>
#include<cmath>
int ds[1001][1001], v[1001],end[1001],vis[1001];
const int INF = 0x3f3f3f3f;
int min(int a, int b)
{
	return a > b ? b : a;
}
int max(int a, int b)
{
	return a > b ? a : b;
}
int main()
{
	int t, s, d, i, j, n,dis,m,minn,pos,k;
	while (scanf("%d%d%d", &t, &s, &d) != EOF)
	{
		memset(v, INF, sizeof v);
		memset(vis, 0, sizeof vis);
		memset(ds, INF, sizeof ds);
		n = 0;
		while (t--)
		{
			scanf("%d%d%d", &i, &j, &dis);
			ds[i][j] = min(ds[i][j], dis);
			ds[j][i] = min(ds[j][i], dis);
			n = max(n, max(i, j));
		}
		while (s--)
		{
			scanf("%d", &j);
			v[j] = 0;
		}
		for (j = 0; j < d; j++)
		{
			scanf("%d", &end[j]);
		}
		for (m = 1; m <= n; m++)
		{
			for (i = 1, minn = INF; i <= n; i++)
				if (v[i] < minn&&!vis[i])
				{
					pos = i;
					minn = v[i];
				}
			vis[pos] = 1;
			for (i = 1; i <= n; i++)
				if (ds[pos][i] < INF&&!vis[i])
					v[i] = min(v[i], ds[pos][i] + v[pos]);
		}
		for (i = 0, minn = INF; i < d; i++)
			if (v[end[i]] < minn)
				minn = v[end[i]];
		printf("%d\n", minn);
	}
	return 0;
}

和佛洛依德：

#include<cstdio>
#include<cstring>
#include<cmath>
int ds[1001][1001], end[1001],beg[1001];
const int INF = 0x3f3f3f3f;
int min(int a, int b)
{
	return a > b ? b : a;
}
int max(int a, int b)
{
	return a > b ? a : b;
}
int main()
{
	int t, s, d, i, j, n,dis,m,minn,pos,k;
	while (scanf("%d%d%d", &t, &s, &d) != EOF)
	{
		memset(ds, INF, sizeof ds);
		n = 0;
		while (t--)
		{
			scanf("%d%d%d", &i, &j, &dis);
			ds[i][j] = min(ds[i][j], dis);
			ds[j][i] = min(ds[j][i], dis);
			n = max(n, max(i, j));
		}
		for (j = 0; j < s; j++)
		{
			scanf("%d", &beg[j]);
		}
		for (j = 0; j < d; j++)
		{
			scanf("%d", &end[j]);
		}
		for (i = 1; i <= n; i++)
			for (j = 1; j <= n; j++)
				if (ds[i][j] < INF)
					for (k = 1; k <= n; k++)
						ds[j][k] = min(ds[j][k], ds[i][j] + ds[i][k]);
		for (i = 0, minn = INF; i < d; i++)
			for (j = 0; j < n; j++)
				if (ds[beg[j]][end[i]] < minn)
					minn = ds[beg[j]][end[i]];
		printf("%d\n", minn);
	}
	return 0;
}

这两个算法在这题上的处理方法差不多，都是找到某个点，然后把该点对于其他点的距离都抛出去，相加并选择小的值来储存。

就迪杰斯特拉算法来说，是从源点开始将它到各个直接相连点的距离先储存到（储存最终到源点距离的数组，下标为标号的）一维数组中，并将抛去的值与所连接的点的储存值比较，储存小的，并重复n（标号的最大值）次。

就佛洛依德而言，是将在储存距离的二维数组中，扫描每一个非最大值的位置（i，j）（一开始该数组全为最大值，也可扫描全部位置但是没有意义，故优化），然后将i行的各个距离抛到j行，即j通过i（若原本储存值更小，则不通过i）能去到其他所有能到达点位的最短路径。这样的过程进行完成后，就将各行终点位置的值储存为直接到终点或者间接到终点的最小值，从而体现佛洛依德算法的核心：最短路分两种情况，直接或通过某些点后到达终点，那么搜索每一个点k，比较distance（i，k）+distance（k，j）和distance（i，j），取其小者储存，这样历遍后便能得到最短路。

所以，就该题而言，迪杰斯特拉算法更为直接，时间消耗较小，但空间消耗也增加。其次，两种算法都是抛出种子（距离）——种子再抛出种子的做法，所以个人认为这是多叉树数据结构，进而可以认为这是DP思想的算法，只是这种DP并不需要状态转移方程，因为只要找到对应点，那么该点就要无条件地进行抛种子。

于是，个人认为，只要是类多叉树数据结构的情况，都可以用DP思想进行解决。（个人看法，欢迎讨论）