Minimum Distance to a Leaf Node in a Weighted Undirected Graph

using System;
using System.Collections.Generic;

class Program
{
    // Function to find distance for each node
    static List<long> DisTree(int n, List<List<int>> edges)
    {
        // Create an adjacency list
        List<List<Tuple<long, long>>> graph = new List<List<Tuple<long, long>>>(n);

        // Initialize adjacency list
        for (int i = 0; i < n; i++)
        {
            graph.Add(new List<Tuple<long, long>>());
        }

        // Iterate over edges
        foreach (List<int> edge in edges)
        {
            long x = edge[0];
            long y = edge[1];
            long w = edge[2];
            graph[(int)x].Add(new Tuple<long, long>(y, w));
            graph[(int)y].Add(new Tuple<long, long>(x, w));
        }

        // Initialize a vector distance
        List<long> distance = new List<long>();
        for (int i = 0; i < n; i++)
        {
            distance.Add(long.MaxValue);
        }

        // Priority queue for Dijkstra's algorithm
        PriorityQueue<Tuple<long, long>> pq = new PriorityQueue<Tuple<long, long>>(
            (x, y) => x.Item1.CompareTo(y.Item1)
        );

        // Nodes having degree 1
        for (int i = 0; i < n; ++i)
        {
            if (graph[i].Count == 1)
            {
                pq.Enqueue(new Tuple<long, long>(0, i));
            }
        }

        // Iterate in queue
        while (!pq.IsEmpty())
        {
            Tuple<long, long> temp = pq.Dequeue();
            long dist = temp.Item1;
            long node = temp.Item2;

            // If distance of node is already less, continue
            if (distance[(int)node] <= dist)
            {
                continue;
            }

            // Assign the distance
            distance[(int)node] = dist;

            // Iterate for nodes attached to node
            foreach (Tuple<long, long> e in graph[(int)node])
            {
                long v = e.Item1;
                long t = e.Item2;

                // If distance is less, enqueue
                if (distance[(int)v] > dist + t)
                {
                    pq.Enqueue(new Tuple<long, long>(dist + t, v));
                }
            }
        }

        // Return the vector
        return distance;
    }

    // Main method
    static void Main(string[] args)
    {
        int n = 3;
        List<List<int>> edges = new List<List<int>>()
        {
            new List<int>() { 0, 1, 5 },
            new List<int>() { 1, 2, 3 }
        };

        // Function call
        List<long> ans = DisTree(n, edges);

        // Print the ans
        foreach (long a in ans)
        {
            Console.Write(a + " ");
        }
    }
}

// Priority Queue implementation
public class PriorityQueue<T>
{
    private List<T> data;
    private Comparison<T> comparison;

    // Constructor
    public PriorityQueue(Comparison<T> comparison)
    {
        data = new List<T>();
        this.comparison = comparison;
    }

    // Method to add an element to the priority queue
    public void Enqueue(T item)
    {
        data.Add(item);
        int ci = data.Count - 1;
        while (ci > 0)
        {
            int pi = (ci - 1) / 2;
            if (comparison(data[ci], data[pi]) >= 0) break;
            T tmp = data[ci]; data[ci] = data[pi]; data[pi] = tmp;
            ci = pi;
        }
    }

    // Method to remove and return the element with the highest priority from the priority queue
    public T Dequeue()
    {
        int li = data.Count - 1;
        T frontItem = data[0];
        data[0] = data[li];
        data.RemoveAt(li);

        --li;
        int pi = 0;
        while (true)
        {
            int ci = pi * 2 + 1;
            if (ci > li) break;
            int rc = ci + 1;
            if (rc <= li && comparison(data[rc], data[ci]) < 0)
                ci = rc;
            if (comparison(data[pi], data[ci]) <= 0) break;
            T tmp = data[pi]; data[pi] = data[ci]; data[ci] = tmp;
            pi = ci;
        }
        return frontItem;
    }

    // Method to retrieve the element with the highest priority from the priority queue without removing it
    public T Peek()
    {
        T frontItem = data[0];
        return frontItem;
    }

    // Property to get the count of elements in the priority queue
    public int Count
    {
        get { return data.Count; }
    }

    // Method to check if the priority queue is empty
    public bool IsEmpty()
    {
        return data.Count == 0;
    }
}