poj1797 - Heavy Transportation

                                   想看更多的解题报告: http://blog.csdn.net/wangjian8006/article/details/7870410
                                     转载请注明出处：http://blog.csdn.net/wangjian8006

题目大意：有n个城市，m条道路，在每条道路上有一个承载量，现在要求从1到n城市最大承载量，而最大承载量就是从城市1到城市n所有通路上的最大承载量
解题思路：其实这个求最大边可以近似于求最短路，只要修改下找最短路更新的条件就可以了

 

/*
4128K 375MS
Dijkstra邻接矩阵
*/
#include <iostream>
using namespace std;
#define MAXV 1010
#define min(a,b) (a<b?a:b)

int map[MAXV][MAXV],n,m;

int dijkstra(){
	int vis[MAXV],d[MAXV],i,j,v;
	for(i=1;i<=n;i++){
		vis[i]=0;
		d[i]=map[1][i];	//这个时候d不代表从1到n的最短路径，而是最大承载量
	}
	for(i=1;i<=n;i++){
		int f=-1;
		for(j=1;j<=n;j++)
			if(!vis[j] && d[j]>f){
				f=d[j];
				v=j;
			}
		vis[v]=1;

		for(j=1;j<=n;j++)
			if(!vis[j] && d[j]<min(d[v],map[v][j])){
				d[j]=min(d[v],map[v][j]);
			}
	}
	return d[n];
}

int main(){
	int t,i,j,sum,a,b,c;
	scanf("%d",&sum);
	for(t=1;t<=sum;t++){
		scanf("%d%d",&n,&m);
		for(i=0;i<=n;i++)
			for(j=0;j<=n;j++)
				map[i][j]=0;
		for(i=1;i<=m;i++){
			scanf("%d%d%d",&a,&b,&c);
			map[a][b]=map[b][a]=c;
		}
		printf("Scenario #%d:\n",t);
		printf("%d\n\n",dijkstra());
	}
	return 0;
}

 

========================================================================================

 

/*
spfa邻接矩阵
4156K 469MS 
*/
#include <iostream>
#include <queue>
using namespace std;
#define MAXV 1010
#define min(a,b) (a<b?a:b)

int map[MAXV][MAXV],n,m;

int spfa(){
	queue <int>q;
	int i,j,v;
	int vis[MAXV],d[MAXV];
	for(i=1;i<=n;i++){
		vis[i]=0;
		d[i]=0;
	}
	q.push(1);
	vis[1]=1;
	while(!q.empty()){
		v=q.front();q.pop();
		vis[v]=0;

		for(i=1;i<=n;i++){
			if(v==1 && map[v][i]){
				d[i]=map[v][i];
				q.push(i);
				vis[i]=1;
				continue;
			}
			if(d[i]<min(d[v],map[v][i])){
				d[i]=min(d[v],map[v][i]);
				if(!vis[i]){
					vis[i]=1;
					q.push(i);
				}
			}
		}
	}
	return d[n];
}

int main(){
	int t,i,j,sum,a,b,c;
	scanf("%d",&sum);
	for(t=1;t<=sum;t++){
		scanf("%d%d",&n,&m);
		for(i=0;i<=n;i++)
			for(j=0;j<=n;j++)
				map[i][j]=0;
		for(i=1;i<=m;i++){
			scanf("%d%d%d",&a,&b,&c);
			map[a][b]=map[b][a]=c;
		}
		printf("Scenario #%d:\n",t);
		printf("%d\n\n",spfa());
	}
	return 0;
}

 

================================================================================

 

/*
bellman-ford邻接矩阵
Time Limit Exceeded
*/
#include <iostream>
using namespace std;
#define MAXV 1010
#define min(a,b) (a<b?a:b)

int map[MAXV][MAXV],n,m;

int bellman_ford(){
	int i,j,v,k;
	int vis[MAXV],d[MAXV];
	for(i=1;i<=n;i++) d[i]=map[1][i];

	for(i=1;i<=n;i++){
		for(j=1;j<=n;j++){
			for(k=1;k<=n;k++){
				if (d[k]<min(d[j],map[j][k]) && map[j][k])  d[k]=min(d[j],map[j][k]);
				if (d[j]<min(d[k],map[k][j]) && map[k][j])  d[j]=min(d[k],map[k][j]);
			}
		}
	}
	
	return d[n];
}

int main(){
	int t,i,j,sum,a,b,c;
	scanf("%d",&sum);
	for(t=1;t<=sum;t++){
		scanf("%d%d",&n,&m);
		for(i=0;i<=n;i++)
			for(j=0;j<=n;j++)
				map[i][j]=0;
			for(i=1;i<=m;i++){
				scanf("%d%d%d",&a,&b,&c);
				map[a][b]=map[b][a]=c;
			}
			printf("Scenario #%d:\n",t);
			printf("%d\n\n",bellman_ford());
	}
	return 0;
}

 

===================================================================================================

 

/*
760K 1532MS
bellman_ford邻接表
*/
#include <iostream>
using namespace std;
#define MAXV 1010
#define MAXE 1000010
#define min(a,b) (a<b?a:b)

struct {
	int s,e,w;
}edge[MAXE];

int n,m;

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

	d[1]=0xffffff;
	
	for (i=1;i<n;i++){
		for (j=1;j<=m;j++){
			if (d[edge[j].e]<min(d[edge[j].s],edge[j].w))  d[edge[j].e]=min(d[edge[j].s],edge[j].w);
			if (d[edge[j].s]<min(d[edge[j].e],edge[j].w))  d[edge[j].s]=min(d[edge[j].e],edge[j].w);
		 }  
	}
	
	return d[n];
}

int main(){
	int t,i,sum;
	scanf("%d",&sum);
	for(t=1;t<=sum;t++){
		scanf("%d%d",&n,&m);
		for(i=1;i<=m;i++){
			scanf("%d%d%d",&edge[i].s,&edge[i].e,&edge[i].w);
		}
		printf("Scenario #%d:\n",t);
		printf("%d\n\n",bellman_ford());
	}
	return 0;
}

 

================================================================================================

 

/*
760K 250MS
bell_ford邻接表优化
*/#include <iostream>
using namespace std;
#define MAXV 1010
#define MAXE 1000010
#define min(a,b) (a<b?a:b)

struct {
	int s,e,w;
}edge[MAXE];

int n,m;

int bellman_ford(){
	int i,j,d[MAXV];
	for(i=1;i<=n;i++) d[i]=0;
	
	d[1]=0xffffff;
	
	int flag=1;
	while(flag){
		flag=0;
		for (j=1;j<=m;j++){
			if (d[edge[j].e]<min(d[edge[j].s],edge[j].w))  {d[edge[j].e]=min(d[edge[j].s],edge[j].w);flag=1;}
			if (d[edge[j].s]<min(d[edge[j].e],edge[j].w))  {d[edge[j].s]=min(d[edge[j].e],edge[j].w);flag=1;}
		}  
	}
	
	return d[n];
}

int main(){
	int t,i,sum;
	scanf("%d",&sum);
	for(t=1;t<=sum;t++){
		scanf("%d%d",&n,&m);
		for(i=1;i<=m;i++){
			scanf("%d%d%d",&edge[i].s,&edge[i].e,&edge[i].w);
		}
		printf("Scenario #%d:\n",t);
		printf("%d\n\n",bellman_ford());
	}
	return 0;
}

 

=======================================================================================

 

/*
bellman-ford邻接矩阵优化
4124K 1485MS 
*/
#include <iostream>
using namespace std;
#define MAXV 1010
#define min(a,b) (a<b?a:b)

int map[MAXV][MAXV],n,m;

int bellman_ford(){
	int i,j,v,k;
	int vis[MAXV],d[MAXV];
	for(i=1;i<=n;i++) d[i]=map[1][i];
	
	int flag=1;
	while(flag){
		flag=0;
		for(j=1;j<=n;j++){
			for(k=1;k<=n;k++){
				if (d[k]<min(d[j],map[j][k]) && map[j][k])  {d[k]=min(d[j],map[j][k]);flag=1;}
				if (d[j]<min(d[k],map[k][j]) && map[k][j])  {d[j]=min(d[k],map[k][j]);flag=1;}
			}
		}
	}
	
	return d[n];
}

int main(){
	int t,i,j,sum,a,b,c;
	scanf("%d",&sum);
	for(t=1;t<=sum;t++){
		scanf("%d%d",&n,&m);
		for(i=0;i<=n;i++)
			for(j=0;j<=n;j++)
				map[i][j]=0;
			for(i=1;i<=m;i++){
				scanf("%d%d%d",&a,&b,&c);
				map[a][b]=map[b][a]=c;
			}
			printf("Scenario #%d:\n",t);
			printf("%d\n\n",bellman_ford());
	}
	return 0;
}