Check if an edge is a part of any Minimum Spanning Tree

// Java program to implement above approach

import java.io.*;
import java.util.*;

// Class to implement disjoint set union
class DSU {
    Map<Integer, Integer> parent = new HashMap<>();
    Map<Integer, Integer> rank = new HashMap<>();

    // Function to find parent of a node
    int find(int x)
    {
        if (!parent.containsKey(x)) {
            rank.put(x, 1);
            parent.put(x, x);
        }
        if (parent.get(x) != x) {
            parent.put(x, find(parent.get(x)));
        }
        return parent.get(x);
    }

    // Function to perform union
    boolean unite(int u, int v)
    {
        int p1 = find(u), p2 = find(v);

        // If do not belong to same set
        if (p1 != p2) {
            if (rank.get(p1) < rank.get(p2)) {
                parent.put(p1, p2);
            }
            else if (rank.get(p1) > rank.get(p2)) {
                parent.put(p2, p1);
            }
            else {
                parent.put(p2, p1);
                rank.put(p1, rank.get(p1) + 1);
            }
            return true;
        }

        // Belong to same set
        else {
            return false;
        }
    }
}

class Solution {

    // Find the MST weight
    int kruskal(boolean include, List<List<Integer> > edges,
                int a, int b)
    {
        DSU obj = new DSU();
        int total = 0;
        // If include is True, then include edge (a, b)
        // first
        if (include) {
            for (List<Integer> edge : edges) {
                int u = edge.get(0), v = edge.get(1),
                    wt = edge.get(2);

                // As graph is undirected so (a, b) or (b,
                // a) is same If found break the for loop
                if ((u == a && v == b)
                    || (u == b && v == a)) {
                    boolean val = obj.unite(a, b);
                    total += wt;
                    break;
                }
            }
        }

        // Go on adding edge to the disjoint set
        for (List<Integer> edge : edges) {
            int u = edge.get(0), v = edge.get(1),
                wt = edge.get(2);

            // Nodes (u, v) not belong to same set include
            // it
            if (obj.unite(u, v)) {
                total += wt;
            }
        }

        // Finally return total weight of MST
        return total;
    }

    // Function to find if edge (a, b) is part of any MST
    boolean solve(List<List<Integer> > edges, int a, int b)
    {
        // Sort edges according to weight in ascending order
        Collections.sort(
            edges, new Comparator<List<Integer> >() {
                @Override
                public int compare(List<Integer> a,
                                   List<Integer> b)
                {
                    return a.get(2) - b.get(2);
                }
            });

        // Not included edge (a, b)
        int overall = kruskal(false, edges, a, b);

        // Find mst with edge (a, b) included
        int inc = kruskal(true, edges, a, b);

        // Finally return true if same else false
        return inc == overall;
    }
}

class GFG {
    public static void main(String[] args)
    {
        Solution obj = new Solution();
        List<List<Integer> > graph = Arrays.asList(
            Arrays.asList(0, 1, 20), Arrays.asList(0, 2, 5),
            Arrays.asList(0, 3, 10),
            Arrays.asList(2, 3, 10));
        int A = 2, B = 3;
        boolean val = obj.solve(graph, A, B);
        if (val) {
            System.out.println("True");
        }
        else {
            System.out.println("False");
        }
    }
}

// This code is contributed by karthik.