小时候的游戏（三）：最短路径算法2

 

对之前的Dijkstra 算法的CODE进行了修改，主要是增加了一个Dijkstra类，继承自Graph，将S、C、D作为Dijkstra类的成员，并对SCD初始化过程用initalSCD方法进行重合，将原Graph类中的findShortestPath方法移动Dijkstra类中。

 

代码如下：

 

import java.util.*;


/*   
 *  Node:
 */

class Node {
	int index;
	
	Node() { 
		index = 0; 
	}
	
	Node(int index) {	
		this.index = index;
	}
	
	void dispNode() {	
		System.out.print(this.index);
	}
}

/*
 * Edge: 
 */
class Edge {
	int weight;
	Node fromNode;
	Node toNode;
	
	Edge(){
		weight = 0;
		fromNode = null;
		toNode = null;
	}
	
	Edge(int v, Node from, Node to)
	{
		weight = v;
		fromNode = from;
		toNode = to;
	}
	
	void dispEdge(){
		System.out.print("<"+fromNode.index+","+toNode.index+":"+weight+">");
	}
} 

/*
 * Graph
 */
class Graph {
	ArrayList<Node> nodes;
	ArrayList<Edge> edges;

	Graph(ArrayList<Node> n, ArrayList<Edge> e){
		nodes = n;
		edges = e;
	}
	
	void dispGraph(){
		System.out.print("Node:\t");
		for(Node n:nodes){
			n.dispNode();
			System.out.printf(" ");
		}
		
		System.out.println();
	
		System.out.print("Edges:\t");
		for(Edge e:edges )
		{
			e.dispEdge();
			System.out.printf(" ");
		}
		System.out.println();
	}
			
	void printState(ArrayList<Node> S, ArrayList<Node> C, int [] D)
	{				
	    System.out.println();
	    System.out.println("========================");
	    
	    //display
	    System.out.print("S:\t{");
	    for(Node n: S)
	    	System.out.print(n.index+" ");
	    System.out.print("}");
	    
	    //display C
	    System.out.println();
	    System.out.print("C:\t{");
	    for (Node n: C)
			System.out.print(n.index+" ");
	    System.out.print("}");
		
	    // display D
		System.out.println();
		System.out.print("D:\t[");
		for (int i:D)
			System.out.print(i+" ");
		System.out.print("]");
		System.out.println();
		//display edges
		
		//dispGraph();
		
	}
	
} // _class Graph
	
class Dijkstra extends Graph {

	ArrayList<Node> S;
	ArrayList<Node> C;
	int[] D;
	Node v;
	
	Dijkstra(ArrayList<Node> n, ArrayList<Edge> e) {
		super(n, e);
		// TODO Auto-generated constructor stub
		S= new ArrayList<Node>();
		C = new ArrayList<Node>();
		D = new int[nodes.size()-1];
		v = new Node();
	}
	
	// for get L(u,v)
	int min(int i,int j){
		return ((i)<(j)) ? (i):(j);
	}
		
	// Get the index of the minimal value in Array[].
	// Caution: The Length of Array depends on NodeList's size. 
	int locMiniOf(ArrayList<Node> nodeList, int[] array)
	{
		// find minimal of D, for get v.
		int id = 0;
		int minimalOfArray = array[0];
		for(int i = 1; i < nodeList.size(); i++)
			minimalOfArray = min(minimalOfArray,array[i]);
						
		// get index of minimalOfD in D[]
		for(int i = 0; i < nodeList.size(); i++)
			if(array[i] == minimalOfArray)
				id = i;
						
		return id;
	}
	
	void initialSCD(){
		// initiate S,C,D;
		// initiate S
		S.add(nodes.get(0));
		// initiate C	
		for (int i=1; i<nodes.size(); i++)
			C.add(nodes.get(i));
		// initiate D
		int k=0;
		for(Edge e:edges) {
			if (e.fromNode.index == 1)
				D[k++] = e.weight;
		}
		 		
		for (int i=0; i<D.length-1; i++)
			if (D[i] == 0)
				D[i] = 10000;
	
		// print S, C, D before start.
		printState(S,C,D);
		System.out.println();	
	}
	
	void findShortestPath() {
		
		// initial S, C, D
		initialSCD();
		
		// start to finding.
		Iterator<Node> it = C.iterator();  
		while(it.hasNext()) {
		
			int id = locMiniOf(C,D);		
			// get v
			v= C.get(id);
			// print v
			System.out.println("v = "+ v.index);
			// update S, C
			S.add(v);
			C.remove(id);
			// update D
			int L = 0;
			for (int i=0; i<C.size(); i++){
				for (Edge e : edges){
					if (e.fromNode.index == v.index && e.toNode.index == C.get(i).index) {
						L = D[id]+ e.weight; 
						D[e.toNode.index-2] = min(D[e.toNode.index-2],L);
					}
				}
				printState(S,C,D);
			}
		}// _while
		
	}// _findShortestPath()
}

class GraphDemo 
{
	public static void main (String[] args) {
		
		// initiate Graph
		int[][] edgesMatrix = {
				{0,50,30,100,10},
				{0,0,0,0,0},
				{0,5,0,0,0},
				{0,20,50,0,3},
				{0,0,0,10,0}
		};
			
		ArrayList<Node> ns = new ArrayList<Node>();
		ArrayList<Edge> es = new ArrayList<Edge>();
	
		// add each Node
		for(int i=1; i<= edgesMatrix.length; i++){
			Node n = new Node(i);
			ns.add(n);
		}		
		// add each edge
		for(int i=0; i<edgesMatrix.length; i++)
			for(int j=0; j<edgesMatrix.length; j++)
				if(edgesMatrix[i][j] != 0) 	{
					Edge e = new Edge(edgesMatrix[i][j], ns.get(i),ns.get(j));
					es.add(e);
				}
		
		// create the instance of Graph
		Dijkstra G = new Dijkstra(ns,es);
		
		// display the Nodes and Edges of Graph
		G.dispGraph();
		
		// find shortest-path from Node 1 to others 
		// The sum of SP's weight be saved at D[]
		G.findShortestPath();
	}
}