Offer 驾到，掘友接招！我正在参与2022春招打卡活动，点击查看活动详情。

一、题目描述：

给定一个 n 个点，m 条有向边的带非负权图，请你计算从 s 出发，到每个点的距离。数据保证你能从 s 出发到任意点。

输入格式

第一行为三个正整数 n, m, s。第二行起 m 行，每行三个非负整数 ui,vi,wi，表示从 ui 到 vi 有一条权值为 wi 的有向边。

输出格式

输出一行 n 个空格分隔的非负整数，表示 s 到每个点的距离。

0 2 4 3

二、思路分析：

Prim算法和Dijkstra算法十分相似，唯一的区别是： Prim算法要寻找的是离已加入顶点距离最近的顶点，Dijkstra算法是寻找离固定顶点距离最近的顶点

这题的输出需要给一个记录每个点到 s 点的最短距离数组，基于贪心算法的思想，根据结点，优先选择权值小的边，记录并刷新每个点到固定点的最短距离。例如定点 s -> c 的边权值为8，我们就刷新结点c的最短距离为8，若固定点 s -> a 的边权值为2， a -> c 的权值为3 , 我们就继续刷新结点c的最短距离为5 。并记录结点c的前驱结点，若是 s -> a -> c 我们就记录c的前驱结点是a ，与prim不同的是， Dijkstra 我们记录的边权值是固定点s->c的距离，而prim记录的是前驱结点a->c的距离

这里的路径数据存储我们采用链表的形式，像列表下标为 3 的链表（4,2）-> (5,3) -> null 表示为结点3有一条与结点4连接权值为2的边、结点3有一条与结点5连接权值为3的边。这样我们可以很容易取数据，这里我们用一个insert函数进行数据存储的链表插入操作。

由于我们会优先选择权值小的边，我们采用一个PriorityQueue优先队列 (comparator)（比较器）在队列实例化的时排序。存入队列中的数据会自动通过边权值进行排序，我们通过比较器设置每次从队列中取出的都是边权值最小的边。

由于输入输出数据很多，我们可以优化输入输出节约时间

三、AC 代码：

import java.io.*;
import java.util.*;
public class keshan {

	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out))) ;
		
		// n,m,s，分别表示点的个数、有向边的个数、出发点的编号
		String [] str = in.readLine().split(" ") ;
		int n = Integer.parseInt(str[0]) ;  
		int m = Integer.parseInt(str[1]) ;  
		int s = Integer.parseInt(str[2]) ;
		
                // 创建大小为n的数组，每一个结点都有一个链表
		AdjList graph = new AdjList(n+1) ;

		for( int i = 0 ; i < m ; i++ ) 
		{	str = in.readLine().split(" ") ;
			int u = Integer.parseInt(str[0]) ;  
			int v = Integer.parseInt(str[1]) ;  
			int w = Integer.parseInt(str[2]) ;
                        // 将m 条有向边以链表的形式存储起来
			graph.insert(u,v,w) ;
		}

		// 创建一个优先队列， queue设置边权值从小到大排列
		PriorityQueue<queue> r = new PriorityQueue<>();
           //将起点加进去
		r.add(new queue(s,0)) ;    
		int ans [] = new int [n+1] ;
           // 首先设置每个点到s点的距离都是最大值
		for( int i = 0 ; i <= n ; i++ )
			ans[i] = Integer.MAX_VALUE ;
           // 取过几个点，当n个点都加入过队列，就可以直接退出了
		int count = 0 ;   
           // b[] 判断这个点是不是加入过队列
		boolean [] b = new boolean[n+1] ;
		while( !r.isEmpty() && count < n )
		{	
                 queue t = r.poll() ;    
		      int to = t.to , w = t.weight ;
                // 加入过队列就换下个查看
			if( b[to] ) continue ;
			
		     b[to] = true ;      //这个点遍历过了
			count++ ;
                // 更新
			ans[to] = w ;
                        
                // 把与这个结点相关的边取出来，如果对应的那个结点没有加入过队列，就加入进去，给优先队列判断
			Node node = graph.list.get(to) ;
			while( node != null )
			{ 
				int tox = node.to , wx = node.weight ;
				if( b[tox] == false )
				{ 
                           // w+wx 当前边的权值+之前一路走来的权值和
					r.add(new queue(tox, w+wx)) ;
				}
				node = node.next ;
			}
 		}
		for( int i = 1 ; i <= n ; i++ )
			out.print(ans[i]+" ");
           //   强制把数据输出，缓存区就清空了
		out.flush();
	}

}
// 比较器
class queue implements Comparable<queue>{	
	int to ;
	int weight ;
	public queue(int to ,int weight ) {
		this.to = to ;
		this.weight = weight ;
	}
	@Override
	public int compareTo(queue o) {
		return this.weight - o.weight ;
	}
	
}
// 链表结构
class Node {
	int to ;        //邻边
	int weight ;     //权
	Node next ;      //下一个节点
	Node ( int to , int weight , Node next )
	{
		this.to = to ;    
		this.weight = weight ;   
		this.next = next ;
	}
}
class AdjList{
	int number ;
	ArrayList<Node> list = new ArrayList<>() ;
	public AdjList(int number) {
		for( int i = 1 ; i <= number ; i++ )
			this.list.add(null) ;
	}
         // index是插入占位为index的链表前面
	public void insert ( int index , int to , int weight )  
	{
		Node node = new Node(to, weight, this.list.get(index) ) ;
		this.list.set(index, node) ;
	}
}

四、总结：

总的来说就是以链表的方式把有向边存起来，根据不断延申的边把路径上的结点保存到队列中（结点与这条路径上的权值和），并不断刷新每个点到s点的最小距离。

单源最短路径 - Dijkstra算法