先上实验报告：

还是比较简单的。

但是开始没有了解过图的遍历，也不知道怎么遍历。

其实也很简单，安利个视频：https://www.bilibili.com/video/av18586085?from=search&seid=6600959381110331126

讲的比较详细。

最小生成树吧，身为一个ACMer，这么简单裸的板子当然好写了。

我用的prim写的，不过没有堆优化。

但是我中间加了个东西，打印建边过程,kruskal加这个东西应该比较简单吧。

prim还是需要思考一下的。

下面代码那个注释图的样子，文本有点不太正。

这样的。

2333

代码：

import java.util.*;
public class Main2 {

	public static void main(String[] args) {
		Graph g=new Graph(5);
		g.addEdge(1, 2,1);
		g.addEdge(4, 2,10);
		g.addEdge(1, 3,1);
		g.addEdge(1, 5,10);
		g.addEdge(3, 5,2);
		
		//这个图的样子大概就是
/*					1
 * 				   /|\
 *   		   	1 / | \10
 * 			     / 1|  \
 * 			4---2   3---5
 *			 10		  2
 */
		System.out.println("广搜结果：");
		g.bfs();
		System.out.println("深搜结果：");
		g.dfs();
		g.prim();
	}

}
class Graph{
	private int map[][];						//临界矩阵表示图
	private int n;								//表示节点个数
	private boolean used[];						//表示用过的边
	public Graph() {}
	public Graph(int n) {
		this.n=n;
		map=new int[n+1][n+1];
		used=new boolean[n+1];
	}
	//=======================================dfs遍历图，但是如果图不连通的话可能遍历不了。
	public void dfs() {
		for(int i=1;i<=n;i++)
			used[i]=false;
		dfs(1);
		System.out.println();
	}
	private  void dfs(int i) {
		used[i]=true;
		System.out.print(i+" ");
		for(int j=1;j<=n;j++) {
			if(map[i][j]!=0&&!used[j]) {
				dfs(j);
			}
		}
	}
	//========================================bfs遍历图
	public void bfs() {
		for(int i=1;i<=n;i++)
			used[i]=false;
		LinkedList<Integer> list=new LinkedList<Integer>();
		list.offer(1);
		used[1]=true;
		while(!list.isEmpty()) {
			int t=list.poll();
			System.out.print(t+" ");
			for(int i=1;i<=n;i++) {
				if(map[t][i]!=0&&!used[i]) {
					used[i]=true;
					list.offer(i);
				}
			}
		}
		System.out.println();
	}
	public void addEdge(int a,int b) {
		map[a][b]=map[b][a]=1;
	}
	public void addEdge(int a,int b,int c) {
		map[a][b]=map[b][a]=c;
	}
/*
 * prim算法其实可以通过优先队列优化到nlogn，但是懒得用了
 * 如果套板子的话感觉太无聊
 * 然后就想了个主意，不如在计算值的同时加一个判断，中间打印生成树的过程。
 * 然后和裸的板子不同，加了个from数组，记录上一个点到这的最小点，然后就完成了这个重大任务。
 * 太晚了，应该没有bug
 * 加这个小东西，完全是一时兴起(sangxinbingkuang)
 * 耽误了不少时间，用了debug
 * 其实prim算法挺好的，时间复杂度可以优化到vlogv
 * 而kruskal算法的复杂度是eloge
 * 空间复杂度上应该就是kruskal比较占优势了。各有好处吧。
 * 但是感觉还是prim算法用的比较多
 * 身为一个ACMer，表示我半年前就学会最小生成树了2333
 */
	public int prim() {
		int from[]=new int[n+1];
		from[1]=1;
		int ans=0;
		for(int i=1;i<=n;i++)
			used[i]=false;
		while(true) {
			int t=-1;
			//确定一个点，如果这个点的from-to 的value最小，那就优先选择这个点。
			for(int i=1;i<=n;i++) {
				if(!used[i]&&(t==-1||(map[from[i]][i]<map[from[t]][t]&&from[i]!=0)))
					t=i;
			}
			//如果更新点后t依然是-2，说明没有点更新了。
			if(t==-1)
				break;
			used[t]=true;
			if(t!=1)
				System.out.println(from[t]+"-->"+t+"="+map[from[t]][t]);
			ans+=map[from[t]][t];
			//更新一个点后，没用过的节点全部都更新一下from。
			for(int i=1;i<=n;i++) {
				if(!used[i]&&(from[i]==0||map[t][i]<map[from[i]][i])&&map[t][i]!=0) {
					from[i]=t;
				}
			}
		}
		System.out.println("最小价值位:"+ans);
		return ans;
	}
}