Minimum difference between any two weighted nodes in Sum Tree of the given Tree

// Java program for the above approach
import java.util.*;

class GFG{

static class pair
{ 
    int first, second; 
    public pair(int first, int second)  
    { 
        this.first = first; 
        this.second = second; 
    }    
} 

// Function to find minimum
// difference between any two node
static void MinimumDifference(int total_weight[],
                              int N)
{
    int min_difference = Integer.MAX_VALUE;

    for(int i = 1; i < N; i++)
    {
        
        // Pairwise difference
        if (total_weight[i] - 
            total_weight[i - 1] < 
            min_difference) 
        {
            min_difference = total_weight[i] -
                             total_weight[i - 1];
        }
    }

    System.out.print(min_difference + "\n");
}

// Function to find total weight
// of each individual node
static void SumTree(Vector<pair> v,
                    int individual_weight[],
                    int N)
{
    
    // Array to store total weight
    // of each node from 1 to N
    int total_weight[] = new int[N];

    // Array to keep track of node
    // previously counted or not
    int visited[] = new int[N];

    // To store node no. from
    /// N-1 lines
    int first, second;

    // To traverse from (N-1)
    // line to 1 line
    for(int i = (N - 2); i >= 0; i--)
    {
        first = v.get(i).first;
        second = v.get(i).second;

        // Node is note visited
        if (visited[second - 1] == 0)
        {
            total_weight[second - 1] += 
            individual_weight[second - 1];

            // Make node visited
            visited[second - 1] = 1;
        }

        total_weight[first - 1] += 
        total_weight[second - 1];

        // Node is note visited
        if (visited[first - 1] == 0)
        {
            total_weight[first - 1] += 
            individual_weight[first - 1];

            // Make node visited
            visited[first - 1] = 1;
        }
    }

    // Sort the total weight of each node
    Arrays.sort(total_weight);

    // Call function to find minimum
    // difference
    MinimumDifference(total_weight, N);
}

// Driver code
public static void main(String[] args)
{
    
    // Total node of rooted tree
    int N = 8;

    Vector<pair> v = new Vector<>();

    // N-1 lines describing
    // rooted tree from top
    // to bottom
    v.add(new pair(1, 4));
    v.add(new pair(1, 6));
    v.add(new pair(6, 2));
    v.add(new pair(6, 3));
    v.add(new pair(2, 5));
    v.add(new pair(2, 7));
    v.add(new pair(2, 8));

    // Array describing weight
    // of each node from 1 to N
    int individual_weight[] = { 3, 5, 8, 10,
                                2, 6, 7, 11 };

    SumTree(v, individual_weight, N);
}
}

// This code is contributed by Amit Katiyar