2014.1.4

* 最小生成树, Minimal Spanning Tree（带权无向图）

    Prime算法，Kruskal算法，两者皆为贪心算法；O（ElogE）；

        1. Prim在稠密图中比Kruskal优，在稀疏图中比Kruskal劣； 

        2. Prim+Heap在任何时候都有令人满意的时间复杂度，但是代价是空间消耗大，算法复杂；

上图转载自，http://noname01.pas.blog.163.com/blog/static/1243636342010101683743714/

    贪心算法：局部最优解能决定全局最优解。简单地说，问题能够分解成子问题来解决，子问题的最优解能递推到最终问题的最优解。

基于数组实现的优先级队列的Prim，MST算法@java/DataStructure/unit13

class Vertex{
	public char label;
	public boolean wasVisited;

	public Vertex(char lab){
		label=lab;
		wasVisited=false;
	}
}

class Edge{
	public int start;
	public int end;
	public int weight;
	public Edge(int start, int end, int weight){
		this.start=start;
		this.end=end;
		this.weight=weight;
	}

	public void display(){
		System.out.println(start+"->"+end+", "+weight);
	}
}

class Queue{
	public Edge [] eArr;
	public int max;
	public int current;

	public Queue(int max){
		this.max=max;
		eArr=new Edge [max];
		current=0;
	}

	public void insert(Edge eTemp){
		int i=current-1;
		for(; i>=0 && eTemp.weight>eArr[i].weight; i--) eArr[i+1]=eArr[i];
		eArr[i+1]=eTemp;
		current++;
	}

	public Edge remove(){
		return eArr[--current];
	}

	public Edge peek(){
		return eArr[current-1];
	}

	public void hasSameEnd(){
		for(int i=current-1; i>=1; i--){
			for(int j=i-1; j>=0; j--){
				if(eArr[i].end==eArr[j].end){
					for(int k=j; k<current-1; k++){
						eArr[k]=eArr[k+1];
					}
					i--;
					current--;
				}
			}
		}
	}

	public boolean isEmpty(){
		return current==0;
	}

	public boolean isFull(){
		return current==max;
	}

	public void display(){
		for(int i=current-1; i>=0; i--){
			eArr[i].display();
		}
	}
}

class Graph{
	private final int MAX_VERTS=20;
	private Vertex vArr[];
	private int adjMat [] [];
	private int number;

	public Graph(){
		vArr=new Vertex[MAX_VERTS];
		adjMat=new int [MAX_VERTS][MAX_VERTS];
		number=0;
		for(int j=0; j<MAX_VERTS; j++)
			for(int k=0; k<MAX_VERTS; k++)
				adjMat[j][k]=0;
	}

	public void add(char lab){
		vArr[number++]=new Vertex(lab);
		for(int i=0; i<number; i++){
			adjMat[number][i]=0;
			adjMat[i][number]=0;
		}
	}

	public void addEdge(int i, int j, int weight){
		adjMat[i][j]=weight;
		adjMat[j][i]=weight;
	}

	public void displayMat(){
		System.out.println("The Adjacent Matrix is: ");
		System.out.print("   ");
		for(int i=0; i<number; i++){
			System.out.print(vArr[i].label+"  ");
		}
		System.out.println();
		for(int i=0; i<number; i++){
			System.out.print(vArr[i].label+" ");
			for(int j=0; j<number; j++){
				if(adjMat[i][j]<10){
					System.out.print(" "+adjMat[i][j]+" ");
				}
				else System.out.print(adjMat[i][j]+" ");
			}
			System.out.println();
		}
	}

	public boolean notExistInIArr(int i, int [] iArr){
		for(int j=0; j<iArr.length; j++){
			if(iArr[j]==i)
				return false;
		}
		return true;
	}

	public void mst(){
		System.out.println("Minimal Spanning Tree of this Graph is: ");
		int [] iArr=new int [number];
		int current=1;
		Queue queue=new Queue(50);
		iArr[0]=0;
		boolean flag=false;
		for(int i=0; i<number; i++){
			if(adjMat[0][i]>0){
				queue.insert(new Edge(0, i, adjMat[0][i]));
				flag=true;
			}
		}
		if(flag==false){
			System.out.println("No Road!");
			return;
		}
		while(current!=number){
			Edge eTemp=queue.remove();
			for(int i=0; i<number; i++){
				if(adjMat[eTemp.end][i]>0 && notExistInIArr(i, iArr)){
					queue.insert(new Edge(eTemp.end, i, adjMat[eTemp.end][i]));
				}
				queue.hasSameEnd();
			}
			iArr[current++]=eTemp.end;
			System.out.println(vArr[eTemp.start].label+"->"+vArr[eTemp.end].label+", "+eTemp.weight);
		}
	}
}

* 最短路径（带权有向图）