解題思路：http://blog.csdn.net/tigerisland45/article/details/60084015

大佬的部落格寫得很清楚了，我不會c++，大致能看懂大佬用c++寫的，所以這篇應該不屬於原創吧，只是把大佬的程式碼用java翻譯了一遍，但是如果只翻譯的話還不能達到完美，因為只翻譯的話，會超時，只有90分，我又仔細研究了一遍，發現大佬的程式碼有個小缺陷就是，當然用c++寫的，時間足夠了。下面我就說一說小缺陷在哪，從下圖開始

從圖中1開始，訪問相鄰的2、3,同時把1標記為已經訪問過的點，那麼從佇列中推出2時，又把2相鄰的1、3、4節點都訪問了，其實1這個節點已經被標記過為訪問過的點，就不需要再訪問了，意思就是已被訪問多的點就不需要出現在迴圈中了。改進的程式碼就是87、88行，當然還需要在Edge類中重寫equals方法。

完整程式碼如下：

/*
 * 
 * 
 * 
6 9
1 2 6
1 3 3
2 3 2
2 4 5
3 4 3 
3 5 4
4 5 2
4 6 3
5 6 5
*
*
4 5 
1 2 4 
1 3 5 
2 3 2 
2 4 3 
3 4 2
 */
import java.util.ArrayList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;

public class _11 {
	static ArrayList<Edge>[] map;
	static Queue<Node> q;
	//static ArrayList<Edge> out;
	static boolean[] vis;
	static int[]  dis;
	static int[]  cost;
	static int n;
	public static void main(String[] args)
	{
		Scanner sin=new Scanner(System.in);
		n=sin.nextInt();
		int m=sin.nextInt();
		map=new ArrayList[n+1];
		q=new PriorityQueue();
		vis=new boolean[n+1];
		dis=new int[n+1];
		cost=new int[n+1];
		for(int i=0;i<=n;i++)
		{
			map[i]=new ArrayList();
			dis[i]=0x3f3f3f;
		}
		for(int j=0;j<m;j++)
		{
		  int start=sin.nextInt();
		  int end=sin.nextInt();
		  int weight=sin.nextInt();
		  map[start].add(new Edge(end,weight));
		  map[end].add(new Edge(start,weight));
		}
		Dijkstra(1);
		int sum=0;
        for(int k=2;k<=n;k++)
        {
        	sum+=cost[k];
        }
        System.out.println(sum);
		// TODO Auto-generated method stub

	}
	static void Dijkstra(int start)
	{

		vis[0]=true;
		//vis[start]=true;
		q.offer(new Node(start,0));
		while(!q.isEmpty())
		{
			Node tmp=q.poll();
			if(!vis[tmp.end])
			{
				vis[tmp.end]=true;
				for(int j=0;j<map[tmp.end].size();j++)
				{
	                int weight=tmp.weight+map[tmp.end].get(j).weight;
	                int end=map[tmp.end].get(j).end;
	                int co=map[tmp.end].get(j).weight;
	                Edge e=new Edge(tmp.end,co);
	                map[end].remove(e);
	                if(weight<dis[end])
	                {
	                	dis[end]=weight;
	                	cost[end]=weight;
	                	q.offer(new Node(end,dis[end]));
	                }
	                if(weight==dis[end])
	                {
	                	cost[end]=Math.min(cost[end],co);
	                }
				}
			}

		}
		
		 
	}
	static class Node implements Comparable
	{
		int end;
		int weight;
		Node(int end,int weight)
		{
			this.end=end;
			this.weight=weight;
		}
		@Override
		public int compareTo(Object arg0) {
			// TODO Auto-generated method stub
			return this.weight-((Node)arg0).weight;
		}
	}
	static class Edge
	{
		int end;
		int weight;
		Edge(int end,int weight)
		{
			this.end=end;
			this.weight=weight;
		}
		@Override
		public boolean equals(Object obj) 
		{
			Edge other=(Edge)obj;
            if(this.end==other.end&&this.weight==other.weight)

		{
           return true; 	
		}
            return false;
		}
		
	}

 

}

修改之後還是有效果的：

最後說一句，我無fuck說，為了驗證自己的想法是正確，我又測試了一下，發現不改進也是能得滿分，這系統我無fuck說，結果如下：