public static int[]dijkstra(int[][]weight ,int start){
		int n = weight.length;
		int[]shortPath = new int[n];
		int Min = Integer.MAX_VALUE;
		int[]visited = new int[n];
		
		shortPath[0] = 0;
		visited[0] = 1;
		
		for(int count=1 ;count<n ;count++){
			int k=-1;
			for(int i=0 ;i<n ;i++){
				if(visited[i]==0&&weight[start][i]<Min){
					k=i;
					Min = weight[start][i];
				}
			}
			visited[k] = 1;
			shortPath[k] = Min;
			for(int i=0;i<n;i++){
				if(visited[i]==0&&weight[start][k]+weight[k][i]<Min){
					weight[start][i] = weight[start][k]+weight[k][i];
				}
			}
			}
		return shortPath;
	}

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.Set;

/**
 * PriorityQueue + Dijkstra算法求单源最短路径
 * 首推此方法
 * 虽然优先级队列优化比堆优化性能差一点，差距很小。
 * 但是优先级队列可以直接使用adt中的PriorityQueue来实现，
 * 而堆优化实现非常复杂。
 * 
 * @author DuXiangYu
 * 
 */
public class Main {

	static int nodeCount;
	static int edgeCount;
	// 邻接表表头数组
	static Node[] firstArray;
	// 最短路径数组
//	static int[] dist;
	// S集合,代表着已经找到最短路径的结点
	static HashSet<Integer> s;
	// 映射集合
	static dist[] distArray;
	// 优先级队列
	static PriorityQueue<dist> pq;
	static int max = 1000000;

	/**
	 * 结点类
	 * 
	 * @author DuXiangYu
	 */
	static class Node {
		// 邻接顶点map
		private HashMap<Integer, Integer> map = null;

		public void addEdge(int end, int edge) {
			if (this.map == null) {
				this.map = new HashMap<Integer, Integer>();
			}
			this.map.put(end, edge);
		}
	}
	
	/**
	 * dist: 保存源结点至每个结点的最短路径
	 * @author DuXiangYu
	 *
	 */
	static class dist implements Comparable<dist> {

		int value;
		int index;
		
		public dist(int value, int index) {
			this.value = value;
			this.index = index;
		}
		
		@Override
		public int compareTo(dist o) {
			if (o.value < this.value) {
				return 1;
			} else if (o.value > this.value) {
				return -1;
			} else {
				return 0;
			}
		}
		
	}

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);
		nodeCount = sc.nextInt();
		edgeCount = sc.nextInt();

		firstArray = new Node[nodeCount + 1];

		for (int i = 0; i < nodeCount + 1; i++) {
			firstArray[i] = new Node();
		}

		for (int i = 0; i < edgeCount; i++) {
			int begin = sc.nextInt();
			int end = sc.nextInt();
			int edge = sc.nextInt();
			firstArray[begin].addEdge(end, edge);
		}
		sc.close();

		long begin = System.currentTimeMillis();
		
		djst();
		
		long end = System.currentTimeMillis();
		
		System.out.println(end - begin + "ms");
	}

	/**
	 * Heap + Dijkstra算法实现
	 */
	private static void djst() {
		s = new HashSet<Integer>();
		pq = new PriorityQueue<dist>(nodeCount);
		distArray = new dist[nodeCount + 1];
		Node tempNode = firstArray[1];
		for (int i = 2; i < nodeCount + 1; i ++) {
			HashMap<Integer, Integer> tempMap = tempNode.map;
			if (tempMap.containsKey(i)) {
				dist d = new dist(tempMap.get(i), i);
				pq.offer(d);
				distArray[i] = d;
			} else {
				dist d = new dist(max, i);
				pq.offer(d);
				distArray[i] = d;
			}
		}
		s.add(1);
		
		while (s.size() < nodeCount) {

			dist d = pq.poll();
			int index = d.index;
			int value = d.value;
			
			s.add(index);
			
			// 用indx这个点去更新它的邻接点到开始点的距离
			HashMap<Integer, Integer> m = firstArray[index].map;
			if (m == null) {
				continue;
			}
			Set<Integer> set = m.keySet();
			Iterator<Integer>it = set.iterator();
			while (it.hasNext()) {
				int num = it.next();
				if (num == 1) {
					continue;
				}
				dist tempDist = distArray[num];
				if (m.get(num) + value < tempDist.value) {
					pq.remove(tempDist);
					tempDist.value = m.get(num) + value;
					pq.offer(tempDist);
					distArray[num] = tempDist;
				}
			}
		}
		
		for (int i = 2; i < nodeCount + 1; i ++) {
			System.out.println(distArray[i].value);
		}
	}

}