CCF-CSP 交通规划 JAVA 2016-09-04 100分

参考资料：

dijkstra和Floyd算法思想：http://www.cnblogs.com/biyeymyhjob/archive/2012/07/31/2615833.html

C++代码版：http://blog.csdn.net/moilk_nepho/article/details/52950546

JAVA优先队列使用：http://www.importnew.com/6932.html

JAVA类中类问题：https://www.baidu.com/s?ie=UTF-8&wd=java%20%E7%B1%BB%E4%B8%AD%E7%B1%BB

Comparable 和Comparator 详解及区别：http://blog.csdn.net/sinat_34979528/article/details/54407678

cannot be cast to java.lang.Comparable解决办法：http://blog.sina.com.cn/s/blog_944bf8ef0101jczp.html

解题思路：

题目要求 “所有城市到首都的最短距离都和原来一样长” 可见这是一个单源最短路径问题。 

且要求出最少要改造多少铁路，即要求：所有符合最短路径条件的边，用这样的边，连通所有点所需要的最小花费。

样例：

package csp2016_09_4;
/**
 * 收获：
 * 到底是对象运算快还是普通运算快 在这里——用静态还是动态好？
 * djs算法和延伸
 * 常见图论算法的写法
 * 类中类的问题
 * final static 
 * List的使用及List[]时要注意每项都实例化
 * 优先队列PriorityQueue
 * Comparator和Comparable区别和使用细节
 * 
 * */
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
  
class Node implements Comparable<Node>{
	//出发点到V点的距离为cost
	public int v=0,cost=0;	
	Node(){}
	Node(int v,int cost){
		this.v = v;
		this.cost = cost;
	}
	public int compare(Node o1, Node o2) {
//		return ((Node)o1).cost-((Node)o2).cost;	//Comparator<默认Object>
		return o1.cost-o2.cost;
	}
	@Override
	public int compareTo(Node o) {
		return this.cost-o.cost;
	}
	
//	public static Comparator<Node> costComparator = new Comparator<Node>(){
//        public int compare(Node c1, Node c2) {
//            return (c1.cost - c2.cost);
//        }
//    };
}

class Edge{
	// 该点到点V的距离为W
	int v,w=0;
	Edge(int v,int w){
		this.v = v;
		this.w = w;
	}
//	int s=0,e=0,w=0;
//	Edge(int s,int e,int w){
//		this.s = s;
//		this.e = e;
//		this.w = w;
//	}
}

public class Main {  
	Main(){
		for (int i = 0; i < G.length; i++) {
			G[i] = new ArrayList();
		}
	}
	final static int MAXN = 10010;
	final static int MAXINT = 0xfffffff;
	
//	ArrayList G[] = new ArrayList[MAXN]; 
	List <Edge>G[] = new ArrayList[MAXN]; 
	boolean vis[] = new boolean[MAXN];	//每个点只应该被访问一次
	int dis[] =new int[MAXN];	//出发点到某点的距离
//	int prev[] = new int[MAXN];	//传统djs，求前驱顶点，得最短路径
	int costo[] = new int[MAXN];	//当满足最短路径条件下，要接通该点所需要的最小花费。
	int n,m;
	
    public static void main(String[] args)  {
    	Main a = new Main();
    	Scanner sc = new Scanner(System.in);
    	a.n = sc.nextInt();
    	a.m = sc.nextInt();
//    	int[][] A = new int[m][3];
//    	for (int i = 0; i < A.length; i++) {
//			for (int j = 0; j < A[i].length; j++) {
//				A[i][j] = sc.nextInt();
//			}
//		}
//    	Main.run();
    	int s,e,w;
    	for (int i = 0; i < a.m; i++) {
    		s = sc.nextInt();
    		e = sc.nextInt();
    		w = sc.nextInt();
//    		Edge edge = a.new Edge(e,w);
    		a.G[s].add(new Edge(e,w));
    		a.G[e].add(new Edge(s,w));	//双向连通
		}
    	a.djs(1);
    	int ans = 0;
    	for (int i = 2; i <= a.n; i++) {	//没有结点0,本题1到1的距离还是0 
    		ans += a.costo[i];
		}
    	System.out.println(ans);
    }
    public void djs(int s){
    	//初始化
    	for (int i = 0; i <= n; i++) {
    		dis[i] = MAXINT;
    		costo[i] = MAXINT;
    		vis[i] = false;
		}
    	//自己到自己肯定是0
    	dis[s] = 0;
    	costo[s] = 0;
    	// 是0不是s 本题不存在结点0		初始开始结点需要是1
    	vis[0] = true;
    	//建立优先队列pq 存储Node结点信息
//    	Node comp = new Node();	//如果调用的是Comparator接口就这样写
//    	Queue<Node> pq = new PriorityQueue<Node>(comp);	
    	Queue<Node> pq = new PriorityQueue<Node>();	
    	//初始化
    	pq.add(new Node(s,0));	

    	Node temp;
    	while(!pq.isEmpty()){
    		temp = pq.poll();	//从最近的开始取  取完删除
    		int v = temp.v;
    		if(!vis[v]){
    			vis[v] = true;
    			//看看你这个点v周围连了几个边
    			int length = G[v].size();
    			//对每个边循环一次
    			for (int i = 0; i < length; i++) {
    				//目标点：vv 
    				int vv = G[v].get(i).v;
    				if(vis[vv]) continue;
    				//从点v到点vv  边长为cost
    				int cost = G[v].get(i).w;
    				//假如从v沿这条边到vv  那么就得到了新的权值
    				int newdis = dis[v] + cost;
    				//eg：A->B=6  A->C=3  C->B=2   已经到C了 发现6>3+2=5
    				if(dis[vv] > newdis){
    					//那起始点A   --->B 的距离就改成5了
    					dis[vv] = newdis;
    					//目前要连通点B且满足最短路径条件  	所需的最小花费就是2了
    					costo[vv] = cost;	//v到VV的花费
    					//下一个，把点B放入pq中
    					pq.add(new Node(vv,dis[vv]));
    				}
    				//eg:A->B=5?	多种距离相同的方案，选取新边最小那个
    				if(dis[vv] == newdis){
    					costo[vv] = Math.min(costo[vv],cost);
    				}
				}
    		}
    	}
    }
}