//Driver Code Starts
#include <iostream>
#include <vector>
#include <queue>
#include <climits>
using namespace std;

// Function to construct adjacency 
vector<vector<vector<int>>> constructAdj(vector<vector<int>> 
                             &edges, int V) {
                                 
    // adj[u] = list of {v, wt}
    vector<vector<vector<int>>> adj(V); 

    for (const auto &edge : edges) {
        int u = edge[0];
        int v = edge[1];
        int wt = edge[2];
        adj[u].push_back({v, wt});
        adj[v].push_back({u, wt}); 
    }
    
    return adj;
}

//Driver Code Ends

// Returns shortest distances from src to all other vertices
vector<int> dijkstra(int V, vector<vector<int>> &edges, int src){
    
    // Create adjacency list
    vector<vector<vector<int>>> adj = constructAdj(edges, V);

    // Create a priority queue to store vertices that
    // are being preprocessed.
    priority_queue<vector<int>, vector<vector<int>>, 
                   greater<vector<int>>> pq;

    // Create a vector for distances and initialize all
    // distances as infinite
    vector<int> dist(V, INT_MAX);

    // Insert source itself in priority queue and initialize
    // its distance as 0.
    pq.push({0, src});
    dist[src] = 0;

    // Looping till priority queue becomes empty (or all
    // distances are not finalized) 
    while (!pq.empty()){
        
        // The first vertex in pair is the minimum distance
        // vertex, extract it from priority queue.
        int u = pq.top()[1];
        pq.pop();

        // Get all adjacent of u.
        for (auto x : adj[u]){
            
            // Get vertex label and weight of current
            // adjacent of u.
            int v = x[0];
            int weight = x[1];

            // If there is shorter path to v through u.
            if (dist[v] > dist[u] + weight)
            {
                // Updating distance of v
                dist[v] = dist[u] + weight;
                pq.push({dist[v], v});
            }
        }
    }

    return dist;
}

//Driver Code Starts

// Driver program to test methods of graph class
int main(){
    int V = 5;
    int src = 0;

    // edge list format: {u, v, weight}
    vector<vector<int>> edges = {{0, 1, 4}, {0, 2, 8}, {1, 4, 6}, 
                                 {2, 3, 2}, {3, 4, 10}};

    vector<int> result = dijkstra(V, edges, src);

    // Print shortest distances in one line
    for (int dist : result)
        cout << dist << " ";
 
    return 0;
}

//Driver Code Ends

//Driver Code Starts
import java.util.*;

class GfG {

    // Construct adjacency list using ArrayList of ArrayList
    static ArrayList<ArrayList<ArrayList<Integer>>> 
                             constructAdj(int[][] edges, int V) {
        // Initialize the adjacency list
        ArrayList<ArrayList<ArrayList<Integer>>> 
                                   adj = new ArrayList<>();

        for (int i = 0; i < V; i++) {
            adj.add(new ArrayList<>());
        }

        // Fill the adjacency list from edges
        for (int[] edge : edges) {
            int u = edge[0];
            int v = edge[1];
            int wt = edge[2];

            // Add edge from u to v
            ArrayList<Integer> e1 = new ArrayList<>();
            e1.add(v);
            e1.add(wt);
            adj.get(u).add(e1);

            // Since the graph is undirected, add edge from v to u
            ArrayList<Integer> e2 = new ArrayList<>();
            e2.add(u);
            e2.add(wt);
            adj.get(v).add(e2);
        }

        return adj;
    }

//Driver Code Ends

    // Returns shortest distances from src to all other vertices
    static int[] dijkstra(int V, int[][] edges, int src) {
        
        // Create adjacency list
        ArrayList<ArrayList<ArrayList<Integer>>> adj = 
                               constructAdj(edges, V);

        // PriorityQueue to store vertices to be processed
        // Each element is a pair: [distance, node]
        PriorityQueue<ArrayList<Integer>> pq = 
          new PriorityQueue<>(Comparator.comparingInt(a -> a.get(0)));

        // Create a distance array and initialize all distances as infinite
        int[] dist = new int[V];
        Arrays.fill(dist, Integer.MAX_VALUE);

        // Insert source with distance 0
        dist[src] = 0;
        ArrayList<Integer> start = new ArrayList<>();
        
        start.add(0);
        start.add(src);
        pq.offer(start);

        // Loop until the priority queue is empty
        while (!pq.isEmpty()) {
            
            // Get the node with the minimum distance
            ArrayList<Integer> curr = pq.poll();
            int d = curr.get(0);
            int u = curr.get(1);

            // Traverse all adjacent vertices of the current node
            for (ArrayList<Integer> neighbor : adj.get(u)) {
                int v = neighbor.get(0);
                int weight = neighbor.get(1);

                // If there is a shorter path to v through u
                if (dist[v] > dist[u] + weight) {
                    // Update distance of v
                    dist[v] = dist[u] + weight;

                    // Add updated pair to the queue
                    ArrayList<Integer> temp = new ArrayList<>();
                    temp.add(dist[v]);
                    temp.add(v);
                    pq.offer(temp);
                }
            }
        }

        // Return the shortest distance array
        return dist;
    }

//Driver Code Starts

    // Driver program to test methods of graph class
    public static void main(String[] args) {
        int V = 5;      
        int src = 0;    

        // Edge list format: {u, v, weight}
        int[][] edges = {
            {0, 1, 4}, {0, 2, 8}, {1, 4, 6},
            {2, 3, 2}, {3, 4, 10}
        };

        // Get shortest path distances
        int[] result = dijkstra(V, edges, src);

        // Print shortest distances in one line
        for (int d : result)
            System.out.print(d + " ");
    }
}

//Driver Code Ends

#Driver Code Starts
import heapq
import sys

# Function to construct adjacency 
def constructAdj(edges, V):
    
    # adj[u] = list of [v, wt]
    adj = [[] for _ in range(V)]

    for edge in edges:
        u, v, wt = edge
        adj[u].append([v, wt])
        adj[v].append([u, wt])

    return adj

#Driver Code Ends

# Returns shortest distances from src to all other vertices
def dijkstra(V, edges, src):
    # Create adjacency list
    adj = constructAdj(edges, V)

    # Create a priority queue to store vertices that
    # are being preprocessed.
    pq = []
    
    # Create a list for distances and initialize all
    # distances as infinite
    dist = [sys.maxsize] * V

    # Insert source itself in priority queue and initialize
    # its distance as 0.
    heapq.heappush(pq, [0, src])
    dist[src] = 0

    # Looping till priority queue becomes empty (or all
    # distances are not finalized) 
    while pq:
        # The first vertex in pair is the minimum distance
        # vertex, extract it from priority queue.
        u = heapq.heappop(pq)[1]

        # Get all adjacent of u.
        for x in adj[u]:
            # Get vertex label and weight of current
            # adjacent of u.
            v, weight = x[0], x[1]

            # If there is shorter path to v through u.
            if dist[v] > dist[u] + weight:
                # Updating distance of v
                dist[v] = dist[u] + weight
                heapq.heappush(pq, [dist[v], v])

    # Return the shortest distance array
    return dist

#Driver Code Starts

# Driver program to test methods of graph class
if __name__ == "__main__":
    V = 5
    src = 0

    # edge list format: {u, v, weight}
    edges =[[0, 1, 4], [0, 2, 8], [1, 4, 6], [2, 3, 2], [3, 4, 10]];

    result = dijkstra(V, edges, src)

    # Print shortest distances in one line
    print(' '.join(map(str, result)))

#Driver Code Ends

//Driver Code Starts
using System;
using System.Collections.Generic;

class GfG {

    // MinHeap Node (stores vertex and its distance)
    class HeapNode {
        public int Vertex;
        public int Distance;

        public HeapNode(int v, int d) {
            Vertex = v;
            Distance = d;
        }
    }

    // Custom MinHeap class
    class MinHeap {
        private List<HeapNode> heap = new List<HeapNode>();

        public int Count => heap.Count;

        private void Swap(int i, int j) {
            var temp = heap[i];
            heap[i] = heap[j];
            heap[j] = temp;
        }

        public void Push(HeapNode node) {
            heap.Add(node);
            int i = heap.Count - 1;

            while (i > 0) {
                int parent = (i - 1) / 2;
                if (heap[parent].Distance <= heap[i].Distance)
                    break;
                Swap(i, parent);
                i = parent;
            }
        }

        public HeapNode Pop() {
            if (heap.Count == 0) return null;

            var root = heap[0];
            heap[0] = heap[heap.Count - 1];
            heap.RemoveAt(heap.Count - 1);
            Heapify(0);

            return root;
        }

        private void Heapify(int i) {
            int smallest = i;
            int left = 2 * i + 1;
            int right = 2 * i + 2;

            if (left < heap.Count && heap[left].Distance < heap[smallest].Distance)
                smallest = left;

            if (right < heap.Count && heap[right].Distance < heap[smallest].Distance)
                smallest = right;

            if (smallest != i) {
                Swap(i, smallest);
                Heapify(smallest);
            }
        }
    }

    // Build adjacency list from edge list
    static List<int[]>[] constructAdj(int[,] edges, int V) {
        List<int[]>[] adj = new List<int[]>[V];
        for (int i = 0; i < V; i++)
            adj[i] = new List<int[]>();

        int E = edges.GetLength(0);
        for (int i = 0; i < E; i++) {
            int u = edges[i, 0];
            int v = edges[i, 1];
            int wt = edges[i, 2];

            adj[u].Add(new int[] { v, wt });
            adj[v].Add(new int[] { u, wt }); // Undirected graph
        }

        return adj;
    }

//Driver Code Ends

    // Dijkstra's algorithm using custom MinHeap
    static int[] dijkstra(int V, int[,] edges, int src) {
        var adj = constructAdj(edges, V);
        int[] dist = new int[V];
        bool[] visited = new bool[V];

        for (int i = 0; i < V; i++)
            dist[i] = int.MaxValue;

        dist[src] = 0;
        MinHeap pq = new MinHeap();
        pq.Push(new HeapNode(src, 0));

        while (pq.Count > 0) {
            HeapNode node = pq.Pop();
            int u = node.Vertex;

            if (visited[u]) continue;
            visited[u] = true;

            foreach (var neighbor in adj[u]) {
                int v = neighbor[0];
                int weight = neighbor[1];

                if (!visited[v] && dist[u] + weight < dist[v]) {
                    dist[v] = dist[u] + weight;
                    pq.Push(new HeapNode(v, dist[v]));
                }
            }
        }

        return dist;
    }

//Driver Code Starts

    // Main method
    static void Main(string[] args) {
        int V = 5;
        int src = 0;

        int[,] edges = {
            {0, 1, 4},
            {0, 2, 8},
            {1, 4, 6},
            {2, 3, 2},
            {3, 4, 10}
        };

        int[] result = dijkstra(V, edges, src);

        foreach (int d in result)
            Console.Write(d + " ");
    }
}

//Driver Code Ends

//Driver Code Starts

class MinHeap {
    constructor() {
        this.heap = [];
    }

    push(val) {
        this.heap.push(val);
        this._heapifyUp(this.heap.length - 1);
    }

    pop() {
        if (this.size() === 0) return null;
        if (this.size() === 1) return this.heap.pop();

        const min = this.heap[0];
        this.heap[0] = this.heap.pop();
        this._heapifyDown(0);
        return min;
    }

    size() {
        return this.heap.length;
    }

    _heapifyUp(index) {
        while (index > 0) {
            const parent = Math.floor((index - 1) / 2);
            if (this.heap[parent][0] <= this.heap[index][0]) break;
            [this.heap[parent], this.heap[index]] = [this.heap[index], 
                                this.heap[parent]];
            index = parent;
        }
    }

    _heapifyDown(index) {
        const n = this.heap.length;
        while (true) {
            let smallest = index;
            const left = 2 * index + 1;
            const right = 2 * index + 2;

            if (left < n && this.heap[left][0] < this.heap[smallest][0]){
                smallest = left;
            }
            
            if (right < n && this.heap[right][0] < this.heap[smallest][0]){
                smallest = right;
            }

            if (smallest === index) break;
            [this.heap[smallest], this.heap[index]] = 
                              [this.heap[index], this.heap[smallest]];
            index = smallest;
        }
    }
}

// Function to construct adjacency 
function constructAdj(edges, V) {
    // adj[u] = list of [v, wt]
    const adj = Array.from({ length: V }, () => []);

    for (const edge of edges) {
        const [u, v, wt] = edge;
        adj[u].push([v, wt]);
        adj[v].push([u, wt]); 
    }

    return adj;
}

//Driver Code Ends

// Returns shortest distances from src to all other vertices
function dijkstra(V, edges, src) {
    
    // Create adjacency list
    const adj = constructAdj(edges, V);

    // Create a min heap to store <distance, node>
    const minHeap = new MinHeap();

    // Create an array for distances and initialize all distances as infinity
    const dist = Array(V).fill(Number.MAX_SAFE_INTEGER);

    // Push the source node with distance 0
    minHeap.push([0, src]);
    dist[src] = 0;

    // Process the heap
    while (minHeap.size() > 0) {
        const [d, u] = minHeap.pop();

        // Traverse all adjacent of u
        for (const [v, weight] of adj[u]) {
            if (dist[v] > dist[u] + weight) {
                dist[v] = dist[u] + weight;
                minHeap.push([dist[v], v]);
            }
        }
    }

    return dist;
}

//Driver Code Starts

// Driver code
const V = 5;
const src = 0;

// edge list format: [u, v, weight]
const edges = [[0, 1, 4], [0, 2, 8], [1, 4, 6], [2, 3, 2], [3, 4, 10]];

const result = dijkstra(V, edges, src);

// Print shortest distances in one line
console.log(result.join(' '));

//Driver Code Ends