单源最短路（Bellman - Ford算法）

最新推荐文章于 2024-12-18 15:10:08 发布

原创最新推荐文章于 2024-12-18 15:10:08 发布 · 396 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#POJ2139 #Java #Bellman-Ford #单源最短路

算法学习专栏收录该内容

8 篇文章

订阅专栏

本文探讨了在牛群中寻找与所有成员平均距离最短的个体问题，通过电影合作网络构建图模型，运用Dijkstra算法计算最短路径，旨在找到社交网络中最具连接性的节点。

题目描述（POJ2139）

牛们最近在拍电影，所以他们准备去玩一个游戏——“六度分割”的变体。游戏是这样进行的：每个牛离自己的距离是0度，如果两个不同的牛同时出现在一个电影里，那么他们之间的距离为1度，如果两只牛从未一起工作，但它们都与第三只牛一起工作，那么他们之间的距离为2度。这N（2<=N<=300）头牛对找出那只牛与所有牛之间的平均距离最短感兴趣。当然，不算上他自己。这些牛拍了M（1<=M<=10000）部电影，并且保证每两个牛之间都有一定的关系。求那一头牛与其它牛距离的平均值最小值，把它乘100输出。

可以这么理解，如果A和B是一个集合里的，AB之间的距离为1
如果B和C是一个集合里的，AC之间的距离为2
自己与自己的距离为1

代码实现

定义一个类，n1到n2的距离为cast

class E{
	int n1, n2, cast;
}

储存数据，将所有的集合储存起来

		Scanner sc = new Scanner(System.in);
		
		int n = sc.nextInt();
		int m = sc.nextInt();
		E [] e = new E[100000];
		int index = 0;
		
		for(int i = 0; i < m; i++){
			
			int num = sc.nextInt();
			int [] team = new int [num];
			
			for(int j = 0; j < num; j++){
				team[j] = sc.nextInt();
			}
			
			for(int j = 0; j < num - 1; j++){
				for(int k = j + 1; k < num; k++){
					E ee = new E();
					ee.n1 = team[j];
					ee.n2 = team[k];
					ee.cast = 1;
					
					e[index++] = ee;
					
			}

处理每一条边

		int result = Integer.MAX_VALUE;
		
		for(int i = 1; i <= n; i++){
			int [] d = new int [n + 1];
			
			for(int j = 1; j <= n; j++){
				d[j] = Integer.MAX_VALUE;
			}
			
			d[i] = 0;
			
			while(true){
				
				boolean update = false;
				
				for(int j = 0; j < e.length; j++){
					if(e[j] == null) break;
					
					if(d[e[j].n1] != Integer.MAX_VALUE){
						if(d[e[j].n2] > d[e[j].n1] + e[j].cast){
							d[e[j].n2] = d[e[j].n1] + e[j].cast;
							update = true;
						}
					}
					
					if(d[e[j].n2] != Integer.MAX_VALUE){
						if(d[e[j].n1] > d[e[j].n2] + e[j].cast){
							d[e[j].n1] = d[e[j].n2] + e[j].cast;
							update = true;
						}
					}
					
				}
				
				if(!update) break;
			}
			
			for(int j = 1; j <= n; j++){
				d[0] += d[j];
			}
			
			if(d[0] * 100 < result && d[0] != 0){
				result = d[0] * 100;
			}
		}
		
		System.out.println(result / (n - 1));