poj2387- Til the Cows Come Home

Bessie is out in the field and wants to get back to the barn to get as much sleep as possible before Farmer John wakes her for the morning milking. Bessie needs her beauty sleep, so she wants to get back as quickly as possible. 

Farmer John's field has N (2 <= N <= 1000) landmarks in it, uniquely numbered 1..N. Landmark 1 is the barn; the apple tree grove in which Bessie stands all day is landmark N. Cows travel in the field using T (1 <= T <= 2000) bidirectional cow-trails of various lengths between the landmarks. Bessie is not confident of her navigation ability, so she always stays on a trail from its start to its end once she starts it. 

Given the trails between the landmarks, determine the minimum distance Bessie must walk to get back to the barn. It is guaranteed that some such route exists.

Input

* Line 1: Two integers: T and N 

* Lines 2..T+1: Each line describes a trail as three space-separated integers. The first two integers are the landmarks between which the trail travels. The third integer is the length of the trail, range 1..100.

Output

* Line 1: A single integer, the minimum distance that Bessie must travel to get from landmark N to landmark 1.

Sample Input

5 5
1 2 20
2 3 30
3 4 20
4 5 20
1 5 100

Sample Output

90

Hint

INPUT DETAILS: 

There are five landmarks. 

OUTPUT DETAILS: 

Bessie can get home by following trails 4, 3, 2, and 1.

自己想的和做的差距真的很大，我用了自己心中的最短路的算法做，WA到死后来发现，我的这个算法他不能回头，也就是完全错误的，虽然和bellman_ford算法很像。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>

#define inf 1<<29  
#define MAXM 2005  
#define MAXV 1005  

typedef struct {
	int a, b, w;
}Edge;

Edge edge[MAXM];
int n, m;

void bellman_ford() {
	int i, j;
	int d[MAXV];
	for (i = 2; i <= n; i++) d[i] = inf;
	d[1] = 0;

	for (i = 1; i <= n; i++) {//走n遍
		for (j = 1; j <= m; j++) {//每天边走一次
			if (d[edge[j].a]>edge[j].w + d[edge[j].b]) d[edge[j].a] = edge[j].w + d[edge[j].b];
			if (d[edge[j].b]>edge[j].w + d[edge[j].a]) d[edge[j].b] = edge[j].w + d[edge[j].a];
		}
	}
	printf("%d\n", d[n]);
}

int main() {
	int i, a, b, c;
	while (~scanf("%d%d", &m, &n)) {
		for (i = 1; i <= m; i++) {
			scanf("%d%d%d", &a, &b, &c);
			edge[i].a = a;
			edge[i].b = b;
			edge[i].w = c;
		}
		bellman_ford();
	}
	return 0;
}

这是正确的代码。

下面是我错误的代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>

#define INF 0x3f3f3f3f
using namespace std;
int a[1010][1010];
int cost[1010];
int main()
{
	int T, N;
	while (scanf("%d%d",&T,&N)!=EOF)
	{
		memset(a, 0, sizeof(a));
		fill(cost, cost + N+1,INF);
		cost[1] = 0;
		for (int i = 0; i < T; i++)
		{
			int x, y, z;
			scanf("%d%d%d", &x, &y, &z);
			if (a[x][y] == 0 || a[x][y] > z)
			{
				a[x][y] = z;
				a[y][x] = z;
			}
		}
		for (int i = 1; i  <N; i++)
		{
			for (int j = 1; j <= N; j++)
			{
				if (a[i][j])
				{
					cost[j] = min(cost[j], a[i][j] + cost[i]);
				}
			}
		}
		printf("%d\n", cost[N]);
	}

	return 0;
}

和上面的代码是很像的，但是我这个算法他不回头，就是从小到大走一遍。

例如：          4 4

                    1 3  10

                    1 2 100

                    3 2 10  

                    2 4  100 

正确答案是120 而我这个算法出来的结果是 200

ps:这个思路是Floyed的。

修改一下变成

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>

#define INF 0x3f3f3f3f
using namespace std;
int a[1010][1010];
int cost[1010];
int main()
{
	int T, N;
	while (scanf("%d%d",&T,&N)!=EOF)
	{
		memset(a, 0, sizeof(a));
		fill(cost, cost + N+1,INF);
		cost[1] = 0;
		for (int i = 0; i < T; i++)
		{
			int x, y, z;
			scanf("%d%d%d", &x, &y, &z);
			if (a[x][y] == 0 || a[x][y] > z)
			{
				a[x][y] = z;
				a[y][x] = z;
			}
		}
		for (int k = 0; k < N; k++) {
			for (int i = 1; i <= N; i++)
			{
				for (int j = 1; j <= N; j++)
				{
					if (a[i][j])
					{
						cost[j] = min(cost[j], a[i][j] + cost[i]);
					}
				}
			}
		}
		printf("%d\n", cost[N]);
	}

	return 0;
}

这样之前的例子也就能通过了，不过时间复杂度是O(n)的立方。

看来我把迪杰斯特拉 贝尔曼 弗洛伊德 这三个搞混了

这三个算法的时间复杂度是递增的，贝尔曼和弗洛伊德可以判断是否存在负圈