UVa 544 - Heavy Cargo

题目：有一个载重无限的卡车运输货物，在城市中每条道路有一个能承受的最大重量，

现在用卡车从一个城市到另一个城市运送货物，问最大的运输重量。

分析：图论，最短路，最小生成树。找一条从起点到终点的路径，使得其中最窄的路段最宽。

从起点开始不断向周围扩散，像dijkstra算法和prime算法一样，只是维护最大值即可。

（如果上述方法不正确，则存在在一个确定点，其后面的确定点可以更新它，则在那个点应该先被找到）

说明：道路是双向的，重复的路径认为是扩建，加和处理。

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

using namespace std;

/*hash_satrt*/
typedef struct hash_node
{
	int  		id;
	char 		name[31];
	hash_node*	next;
}hash_node;
hash_node  Node[202];
hash_node* List[10007];
int        list_size = 0;

void hash_initial()
{
	list_size = 0;
	memset(List, 0, sizeof(List));
	memset(Node, 0, sizeof(Node));
}

int hash_hash(char *word)
{
	int value = 0;
	for (int i = 0 ; word[i] ; ++ i)
		value = value * word[i] % 10007;
	return value;
}

int hash_find(char *word)
{
	int value = hash_hash(word);
	for (hash_node *p = List[value] ; p ; p = p->next)
		if (!strcmp(p->name, word))
			return p->id;
	Node[list_size].id = list_size;
	strcpy(Node[list_size].name, word);
	Node[list_size].next = List[value];
	List[value] = &Node[list_size ++];
	return list_size-1;
}
/*hash_end*/

int  maps[101][101];
int  path[101],used[101];
char buf1[31],buf2[31];

int deal(int s, int t, int n)
{
	for (int i = 0 ; i < n ; ++ i)
		path[i] = used[i] = 0;

	path[s] = 10001;
	used[s] = 1;
	for (int i = 1 ; i < n ; ++ i) {
		for (int j = 0 ; j < n ; ++ j)
			if (!used[j] && maps[s][j])
				path[j] = max(path[j], min(maps[s][j], path[s]));
		int Max = 0;
		for (int j = 0 ; j < n ; ++ j)
			if (!used[j] && Max < path[j]) {
				s = j;
				Max = path[j];
			}
		used[s] = 1;
	}
	return path[t];
}

int main()
{
	int m,n,p,a,b,Case = 1;
	while (~scanf("%d%d",&n,&m) && n) {
		hash_initial();

		memset(maps, 0, sizeof(maps));
		for (int i = 0 ; i < m ; ++ i) {
			scanf("%s%s%d",buf1,buf2,&p);
			a = hash_find(buf1);
			b = hash_find(buf2);
			maps[a][b] += p;
			maps[b][a] += p;
		}

		scanf("%s%s",buf1,buf2);
		printf("Scenario #%d\n",Case ++);
		printf("%d tons\n\n",deal(hash_find(buf1), hash_find(buf2), n));
	}
    return 0;
}