import javafx.util.Pair;

import java.io.*;
import java.util.Comparator;
import java.util.HashMap;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class Main {

    private static PrintWriter printWriter;
    private static MyScanner scanner;

    private static final int MAX_N = 50001;
    private static final int INFINITY = 2147483647;

    private static int[] dist = new int[MAX_N];
    private static int[] prev = new int[MAX_N];
    private static HashMap<Pair<Integer, Integer>, Integer> ponderi = new HashMap<>();
 //   private static int[][] ponderi = new int[MAX_N][MAX_N];         // 0 here is actually INFINITY and -1 is actually 0

    public static void main(String[] args) throws IOException {
        scanner = new MyScanner("dijkstra.in");
        printWriter = new PrintWriter("dijkstra.out");

        PriorityQueue<Node> queue = new PriorityQueue<Node>(11, new NodeComparator());

        int n, m;
        n = scanner.nextInt();
        m = scanner.nextInt();

        for (int i = 0; i < m; i++) {
            int a = scanner.nextInt();
            int b = scanner.nextInt();
            int c = scanner.nextInt();
         //   if (c == 0)
         //       c = -1;
            ponderi.put(new Pair<>(a, b), c);
           // ponderi[a][b] = c;
        }

        dist[1] = 0;
        queue.add(new Node(1, dist[1]));
        for (int i = 2; i <= n; i++) {
            dist[i] = INFINITY;
            queue.add(new Node(i, dist[i]));
        }

        while (!queue.isEmpty()) {
            Node node = queue.poll();

            for (int i = 1; i <= n; i++) {
                if (node.dist != INFINITY && ponderi.containsKey(new Pair<>(node.vertex, i))) {
                    if (queue.contains(new Node(i, dist[i]))) {
                        int alt = node.dist + ponderi.get(new Pair<>(node.vertex, i));
                        if (alt < dist[i]) {
                            dist[i] = alt;
                            prev[i] = node.vertex;
                            queue.remove(new Node(i, dist[i]));
                            queue.add(new Node(i, dist[i]));
                        }
                    }
                }
            }
        }

        for (int i = 2; i <= n; i++)
            printWriter.printf("%d ", dist[i]);

        printWriter.close();
        scanner.close();
    }

    private static class Node {
        int vertex;
        int dist;

        Node(int vertex, int dist) {
            this.vertex = vertex;
            this.dist = dist;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;

            Node node = (Node) o;

            return vertex == node.vertex;
        }

        @Override
        public int hashCode() {
            return vertex;
        }
    }

    public static class NodeComparator implements Comparator<Node>
    {
        @Override
        public int compare(Node o1, Node o2) {
            int res = o1.dist - o2.dist;
            return res;
        }
    }

    private static class MyScanner
    {
        private BufferedReader bufferedReader;
        private StringTokenizer stringTokenizer;

        MyScanner(String filename) throws FileNotFoundException {
            bufferedReader = new BufferedReader(new FileReader(filename));
        }

        private String next() throws IOException {
            while(stringTokenizer == null || !stringTokenizer.hasMoreElements()) {
                stringTokenizer = new StringTokenizer(bufferedReader.readLine());
            }
            return stringTokenizer.nextToken();
        }

        int nextInt() throws IOException {
            return Integer.parseInt( next() );
        }

        void close() throws IOException {
            bufferedReader.close();
        }
    }
}