Find Edge Weights in a Spanning Tree with Edge (u, v)

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

class Edge implements Comparable<Edge> {
    int weight, id, u, v;

    Edge(int weight, int id, int u, int v)
    {
        this.weight = weight;
        this.id = id;
        this.u = u;
        this.v = v;
    }

    // Compare edges based on weights
    public int compareTo(Edge other)
    {
        return Integer.compare(this.weight, other.weight);
    }
}

public class Main {

    static int[][] ancestor = new int[200005][50];
    static int[] depth = new int[200005];
    static int[][] maxWeight = new int[200005][50];
    static int[] parent = new int[200005];
    static int[] subtreeSize = new int[200005];
    static boolean[] included = new boolean[200005];
    static ArrayList<int[]>[] adjacencyList
        = new ArrayList[200005];
    static ArrayList<Edge> edges = new ArrayList<>();
    static ArrayList<Edge> queries = new ArrayList<>();

    static
    {
        for (int i = 0; i < 200005; i++) {
            adjacencyList[i] = new ArrayList<>();
        }
    }

    // Function to find the Lowest Common Ancestor (LCA) and
    // maximum weight on the path
    static int findLCA(int u, int v)
    {
        int ans = -1;
        if (depth[u] != depth[v]) {
            if (depth[u] < depth[v]) {
                int temp = u;
                u = v;
                v = temp;
            }
            int k = depth[u] - depth[v];

            // Iterate through binary representation of k
            for (int i = 0; (1 << i) <= k; i++) {
                if ((k >> i & 1) == 1) {
                    ans = Math.max(ans, maxWeight[u][i]);
                    u = ancestor[u][i];
                }
            }
        }
        if (u == v)
            return ans;

        // Find the LCA by moving up the tree in powers of 2
        int k = (int)(Math.log(depth[u]) / Math.log(2));
        for (int i = k; i >= 0; i--) {
            if (ancestor[u][i] != ancestor[v][i]) {
                ans = Math.max(Math.max(maxWeight[u][i],
                                        maxWeight[v][i]),
                               ans);
                u = ancestor[u][i];
                v = ancestor[v][i];
            }
        }
        return Math.max(Math.max(ans, maxWeight[u][0]),
                        maxWeight[v][0]);
    }

    // Depth-first search to construct ancestor and
    // maxWeight arrays
    static void dfs(int u)
    {
        for (int[] x : adjacencyList[u]) {
            int v = x[0];
            int weight = x[1];
            if (v == ancestor[u][0])
                continue;
            ancestor[v][0] = u;
            maxWeight[v][0] = weight;
            depth[v] = depth[u] + 1;

            // Build ancestor and maxWeight arrays using
            // dynamic programming
            for (int j = 1; j <= 20; j++) {
                ancestor[v][j]
                    = ancestor[ancestor[v][j - 1]][j - 1];
                maxWeight[v][j] = Math.max(
                    maxWeight[ancestor[v][j - 1]][j - 1],
                    maxWeight[v][j - 1]);
            }
            dfs(v);
        }
    }

    // Function to find the parent of a node using path
    // compression
    static int findParent(int u)
    {
        if (u == parent[u])
            return u;
        return parent[u] = findParent(parent[u]);
    }

    // Function to join two sets using union by size
    static void unionSets(int u, int v)
    {
        u = findParent(u);
        v = findParent(v);
        if (subtreeSize[u] < subtreeSize[v]) {
            int temp = u;
            u = v;
            v = temp;
        }
        subtreeSize[u] += subtreeSize[v];
        parent[v] = u;
    }

    public static void main(String[] args)
    {
        int n = 5, m = 7;
        int[] weightList = { 3, 1, 5, 2, 3, 2, 4 };
        int[] uList = { 1, 1, 1, 2, 2, 3, 4 };
        int[] vList = { 2, 3, 4, 3, 5, 4, 5 };

        // Input the edges
        for (int i = 1; i <= m; i++) {
            int u = uList[i - 1], v = vList[i - 1],
                weight = weightList[i - 1];
            queries.add(new Edge(weight, i, u, v));
            edges.add(new Edge(weight, i, u, v));
        }

        // Sorting edges based on weights
        Collections.sort(edges);

        // Variable to store the total weight of the minimum
        // spanning tree
        int totalWeight = 0;

        // Initialize parent and subtreeSize arrays for
        // union-find
        for (int i = 1; i <= n; i++) {
            parent[i] = i;
            subtreeSize[i] = 1;
        }

        // Construct the minimum spanning tree
        for (Edge x : edges) {
            int weight = x.weight;
            int u = x.u;
            int v = x.v;
            int parentU = findParent(u);
            int parentV = findParent(v);
            if (parentU == parentV)
                continue;
            totalWeight += weight;
            included[x.id] = true;
            unionSets(u, v);
            adjacencyList[u].add(new int[] { v, weight });
            adjacencyList[v].add(new int[] { u, weight });
        }

        // Depth-first search to construct ancestor and
        // maxWeight arrays
        dfs(1);

        // Process each query
        for (Edge x : queries) {
            int weight = x.weight;
            int u = x.u;
            int v = x.v;

            // Check if the edge is already included in the
            // minimum spanning tree
            if (included[x.id]) {
                System.out.print(totalWeight + " ");
                continue;
            }

            // Find the weight of the Lowest Common Ancestor
            // (LCA)
            int lcaWeight = findLCA(u, v);

            // Output the minimum spanning tree weight with
            // the current edge
            System.out.print(totalWeight - lcaWeight
                             + weight + " ");
        }
    }
}