普里姆算法的基本介绍和实现方法（Java）

应用场景-修路问题

题目：有胜利乡有7个村庄(A, B, C, D, E, F, G) ，现在需要修路把7个村庄连通
各个村庄的距离用边线表示(权) ，比如 A – B 距离 5公里
问：如何修路保证各个村庄都能连通，并且总的修建公路总里程最短?
思路:

• er 将10条边，连接即可，但是总的里程数不是最小.
• 正确的思路，就是尽可能的选择少的路线，并且每条路线最小，保证总里程数最少.

最小生成树：

修路问题本质就是就是最小生成树问题， 先介绍一下最小生成树(Minimum Cost Spanning Tree)，简称MST。

• 给定一个带权的无向连通图,如何选取一棵生成树,使树上所有边上权的总和为最小,这叫最小生成树
• N个顶点，一定有N-1条边
• 包含全部顶点
• N-1条边都在图中
• 应用场景：普里姆算法和克鲁斯卡尔算法

普利姆(Prim)算法的介绍

普利姆(Prim)算法求最小生成树，也就是在包含n个顶点的连通图中，找出只有(n-1)条边包含所有n个顶点的连通子图，也就是所谓的极小连通子图
普利姆的算法如下:

• 设G=(V,E)是连通网，T=(U,D)是最小生成树，V,U是顶点集合，E,D是边的集合
• 若从顶点u开始构造最小生成树，则从集合V中取出顶点u放入集合U中，标记顶点v的visited[u]=1
• 若集合U中顶点ui与集合V-U中的顶点vj之间存在边，则寻找这些边中权值最小的边，但不能构成回路，将顶点vj加入集合U中，将边（ui,vj）加入集合D中，标记visited[vj]=1
• 重复步骤②，直到U与V相等，即所有顶点都被标记为访问过，此时D中有n-1条边
  普利姆算法图解：
  

详细代码：

package Prim;

import java.util.Arrays;

public class PrimAlgorithm {

	public static void main(String[] args) {
		char[] data = new char[]{'A','B','C','D','E','F','G'};
		int vertex = data.length;
		MGraph mGraph = new MGraph(vertex);
		int [][]weight=new int[][]{
            {10000,5,7,10000,10000,10000,2},
            {5,10000,10000,9,10000,10000,3},
            {7,10000,10000,10000,8,10000,10000},
            {10000,9,10000,10000,10000,4,10000},
            {10000,10000,8,10000,10000,5,4},
            {10000,10000,10000,4,5,10000,6},
            {2,3,10000,10000,4,6,10000},};
		MinTree minTree = new MinTree();
		minTree.createGraph(vertex, data, mGraph, weight);
		minTree.showGraph(mGraph);
		minTree.PrimTree(mGraph, 0);
	}

}
class MinTree{
	/**
	 * 
	 * @Title: createGraph
	 * @Description: 创建图的邻接矩阵
	 * @param @param vertex 顶点数
	 * @param @param data 顶点存放的数据
	 * @param @param mGraph MGraph类的对象
	 * @param @param weight 参数 每条边的权值
	 * @return
	 */
	public void createGraph(int vertex,char[] data,MGraph mGraph,int[][] weight) {
		for(int i =0;i<vertex;i++) {
			mGraph.data[i]=data[i];
			for(int j =0;j<vertex;j++) {
				mGraph.weight[i][j]=weight[i][j];
			}
		}
	}
	//遍历图
	public void showGraph(MGraph mGraph) {
		for(int[] link:mGraph.weight) {
			System.out.println(Arrays.toString(link));
		}
	}
	/**
	 * 
	 * @Title: PrimTree
	 * @Description: 建立以个最小生成树
	 * @param @param mGraph 传入一个邻接图
	 * @param @param v 从v开始建立
	 * @return
	 */
	public void PrimTree(MGraph mGraph,int v) {
		//表示结点是否被访问，如果被访问则为1，否则为0
		int[] isVisited = new int[mGraph.vertex];
		//下标为v的结点被访问
		isVisited[v] = 1;
		int minWeight = 10000;
		//表示要生成vertex-1条边
		for(int k = 1 ; k <mGraph.vertex;k++) {
			//记录的到的权值最小的边
			int h1 = -1;
			int h2 = -1;
			//假设下标为i的结点已经被访问了，遍历与i邻接的结点找到权值最小的值
			for(int i = 0 ; i < mGraph.vertex;i++) {
				//假设j未被访问
				for(int j = 0;j<mGraph.vertex;j++) {
					if(isVisited[i]==1&&isVisited[j]==0&&minWeight>mGraph.weight[i][j]) {
						minWeight = mGraph.weight[i][j];
						//记录当前结点
						h1=i;
						h2=j;
					}
				}
			}
			System.out.println("当前边：<"+mGraph.data[h1]+","+mGraph.data[h2]+"> 权值为："+minWeight);
			//将当前找到的结点中未被访问的接待你标记为已访问
			isVisited[h2] = 1;
			//重置minWeight
			minWeight = 10000;
		}
	}
}

class MGraph{
	int vertex;//顶点个数
	char[] data;//顶带存放的数据
	int[][] weight;//顶点间的边的权值
	
	public MGraph(int vertex) {
		this.vertex = vertex;
		data = new char[vertex];
		weight = new int[vertex][vertex];
	}
}

算法精髓：

for(int i = 0 ; i < mGraph.vertex;i++) {
	//假设j未被访问
	for(int j = 0;j<mGraph.vertex;j++) {
		if(isVisited[i]==1&&isVisited[j]==0&&minWeight>mGraph.weight[i][j]) {
			minWeight = mGraph.weight[i][j];
			//记录当前结点
			h1=i;
			h2=j;
		}
	}
}

该算法的主要难点在于上面的两层循环嵌套，第一层表示寻找到已被访问的结点，然后对应该结点在第二层中找到该结点的邻接结点所对应的权值，得到下标为i的结点的最小权值，然后再通过第一层循环与其他已经被访问的结点的最小权值进行比较，以此找到权值最小的一条边。然后再循环n-1次找到n-1条边，用这些边构成一颗最小生成树