Queries to find sum of distance of a given node to every leaf node in a Weighted Tree

// C# program for the above problem
using System;
using System.Collections.Generic;
class GFG {
    
    // MAX size
    static int N = 100005;
     
    // Graph with {destination, weight}
    static List<List<Tuple<int,int>>> v = new List<List<Tuple<int,int>>>();
     
    // For storing the sum for ith node
    static int[] dp = new int[N];
     
    // Leaves in subtree of ith.
    static int[] leaves = new int[N];
    
    // dfs to find sum of distance
    // of leaves in the subtree of
    // a node
    static void dfs(int a, int par)
    {
        // flag is the node is
        // leaf or not
        bool leaf = true;
         
        foreach(Tuple<int,int> i in v[a])
        {
            // Skipping if parent
            if (i.Item1 == par)
                continue;
     
            // Setting flag to false
            leaf = false;
     
            // Doing dfs call
            dfs(i.Item1, a);
        }
     
        // Doing calculation
        // in postorder.
        if (leaf == true)
        {
            // If the node is leaf then
            // we just increment
            // the no. of leaves under
            // the subtree of a node
            leaves[a] += 1;
        }
        else
        {
            foreach(Tuple<int,int> i in v[a])
            {
                if (i.Item1 == par)
                    continue;
     
                // Adding num of leaves
                leaves[a] += leaves[i.Item1];
     
                // Calculating answer for
                // the sum in the subtree
                dp[a] = (dp[a] + dp[i.Item1] + leaves[i.Item1] * i.Item2);
            }
        }
    }
     
    // dfs function to find the
    // sum of distance of leaves
    // outside the subtree
    static void dfs2(int a, int par)
    {
        foreach(Tuple<int,int> i in v[a])
        {
            if (i.Item1 == par)
                continue;
     
            // Number of leaves other
            // than the leaves in the
            // subtree of i
            int leafOutside = leaves[a] - leaves[i.Item1];
     
            // Adding the contribution
            // of leaves outside to
            // the ith node
            dp[i.Item1] += (dp[a] - dp[i.Item1]);
     
            dp[i.Item1] += i.Item2 * (leafOutside - leaves[i.Item1]);
     
            // Adding the leaves outside
            // to ith node's leaves.
            leaves[i.Item1] += leafOutside;
            dfs2(i.Item1, a);
        }
    }
     
    static void answerQueries(List<int> queries)
    {
        // Calculating the sum of
        // distance of leaves in the
        // subtree of a node assuming
        // the root of the tree is 1
        dfs(1, 0);
     
        // Calculating the sum of
        // distance of leaves outside
        // the subtree of node
        // assuming the root of the
        // tree is 1
        dfs2(1, 0);
     
        // Answering the queries
        for(int i = 0; i < queries.Count; i++)
            Console.WriteLine(dp[queries[i]]);
    }

  static void Main() {
    // Driver Code
    /*
             1
       (4) /   \ (2)
          /     \
         4       2
             (5)/  \ (3)
               /    \
              5      3
    */
    
    for(int i = 0; i < N; i++)
    {
        v.Add(new List<Tuple<int,int>>());
    }
 
    // initialising tree
    v[1].Add(new Tuple<int,int>(4,4));
    v[4].Add(new Tuple<int,int>(1,4));
    v[1].Add(new Tuple<int,int>(2,2));
    v[2].Add(new Tuple<int,int>(1,2));
    v[2].Add(new Tuple<int,int>(3,3));
    v[3].Add(new Tuple<int,int>(2,3));
    v[2].Add(new Tuple<int,int>(5,5));
    v[5].Add(new Tuple<int,int>(2,5));
 
    List<int> queries = new List<int>{ 1, 3, 5 };
    answerQueries(queries);
  }
}

// This code is contributed by suresh07.