Maximum product of a pair of nodes from largest connected component in a Graph

// Java code to implement the approach
import java.util.*;
class GFG {

  // Stores the first and second largest
  // element in a connected component
  static int Max, sMax, cnt;


  // Function to perform DFS Traversal
  // on a given graph and find the first
  // and the second largest elements
  static void dfs(int u, int N, List<Boolean> vis,
                  List<List<Integer> > adj) {

    // Update the maximum value
    if (u > Max) {
      sMax = Max;
      Max = u;
    } 

    // Update the second max value
    else if (u > sMax) {
      sMax = u;
    }

    // Increment size of component
    cnt++;

    // Mark current node visited
    vis.set(u, true);

    // Traverse the adjacent nodes
    for (int i = 0; i < adj.get(u).size(); i++) {
      int to = adj.get(u).get(i);

      // If to is not already visited
      if (!vis.get(to)) {
        dfs(to, N, vis, adj);
      }
    }
  }

  // Function to find the maximum
  // product of a connected component
  static int MaximumProduct(int N, List<int[]> Edge, List<Integer> wt) {
    int M = wt.size();

    // Stores all the edges mapped
    // with a particular weight
    Map<Integer, List<int[]> > mp = new HashMap<>();
    for (int i = 0; i < M; i++) {
      if (!mp.containsKey(wt.get(i))) {
        mp.put(wt.get(i), new ArrayList<>());
      }
      mp.get(wt.get(i)).add(Edge.get(i));
    }
    List<Integer> keys = new ArrayList<>(mp.keySet());
    Collections.sort(keys, Collections.reverseOrder());

    // Stores the result
    int res = 0;

    // Traverse the map mp
    for (Integer i : keys) {
      List<List<Integer> > adj = new ArrayList<>();
      for (int j = 0; j <= N; j++)
        adj.add(new ArrayList<>());

      // Stores the edges of
      // a particular weight
      List<int[]> v = mp.get(i);

      // Traverse the vector v
      for (int j = 0; j < v.size(); j++) {
        int U = v.get(j)[0];
        int V = v.get(j)[1];
        adj.get(U).add(V);
        adj.get(V).add(U);
      }

      // Stores the maximum
      // size of a component
      List<Boolean> vis = new ArrayList<>();
      for (int j = 0; j <= N; j++)
        vis.add(false);
      int cntMax = 0;
      for (int u = 1; u <= N; u++) {

        // Assign Max, sMax, count = 0
        Max = 0;
        sMax = 0;
        cnt = 0;

        // If vertex u is not visited
        if (!vis.get(u)) {
          dfs(u, N, vis, adj);

          // If cnt is greater
          // than cntMax
          if (cnt > cntMax) {

            // Update the res
            res = Max * sMax;
            cntMax = cnt;
          } 

          // If already largest
          // connected component
          else if (cnt == cntMax) {

            // Update res
            res = Math.max(res, Max * sMax);
          }
        }
      }
    }
    return res;
  }


  // Driver code
  public static void main(String[] args) {
    int N = 5;
    List<int[]> Edges = new ArrayList<>();
    Edges.add(new int[]{1, 2});
    Edges.add(new int[]{2, 5});
    Edges.add(new int[]{3, 5});
    Edges.add(new int[]{4, 5});
    Edges.add(new int[]{1, 2});
    Edges.add(new int[]{2, 3});
    Edges.add(new int[]{3, 4});

    List<Integer> Weights = Arrays.asList(1, 1, 1, 1, 2, 2, 2);

    System.out.println(MaximumProduct(N, Edges, Weights));
  }
}

// This code is contributed by phasing17

import java.util.*;

class DSU {
    private int[] parent;
    private int[] rank;
    private int[] maxNode;

    public DSU(int size)
    {
        parent = new int[size];
        rank = new int[size];
        maxNode = new int[size];
        for (int i = 0; i < size; ++i) {
            parent[i] = i;
            rank[i] = 1;
            maxNode[i] = i;
        }
    }

    public int find(int x)
    {
        if (parent[x] != x)
            parent[x] = find(parent[x]);
        return parent[x];
    }

    public void union(int x, int y)
    {
        int xr = find(x), yr = find(y);
        if (xr == yr)
            return;
        else if (rank[xr] < rank[yr]) {
            parent[xr] = yr;
            maxNode[yr]
                = Math.max(maxNode[xr], maxNode[yr]);
        }
        else if (rank[xr] > rank[yr]) {
            parent[yr] = xr;
            maxNode[xr]
                = Math.max(maxNode[xr], maxNode[yr]);
        }
        else {
            parent[yr] = xr;
            rank[xr]++;
            maxNode[xr]
                = Math.max(maxNode[xr], maxNode[yr]);
        }
    }

    public int getMaxNode(int x) { return maxNode[x]; }
}

public class MaximumProduct {
    public static int maximumProduct(int N, int[][] Edges,
                                     int[] Weight)
    {
        Map<Integer, List<int[]> > edgeMap
            = new HashMap<>();
        for (int i = 0; i < Edges.length; ++i) {
            int u = Edges[i][0], v = Edges[i][1];
            edgeMap
                .computeIfAbsent(Weight[i],
                                 k -> new ArrayList<>())
                .add(new int[] { u, v });
        }

        int maxProduct = 0;

        for (Map.Entry<Integer, List<int[]> > entry :
             edgeMap.entrySet()) {
            int weight = entry.getKey();
            List<int[]> edges = entry.getValue();
            DSU dsu
                = new DSU(N + 1); // Using 1-based indexing
            for (int[] edge : edges)
                dsu.union(edge[0], edge[1]);

            Map<Integer, List<Integer> > componentMax
                = new HashMap<>();
            for (int i = 1; i <= N; ++i) {
                int root = dsu.find(i);
                componentMax
                    .computeIfAbsent(root,
                                     k -> new ArrayList<>())
                    .add(i);
            }

            for (List<Integer> nodes :
                 componentMax.values()) {
                if (nodes.size() >= 2) {
                    Collections.sort(
                        nodes, Collections.reverseOrder());
                    maxProduct = Math.max(
                        maxProduct,
                        nodes.get(0) * nodes.get(1));
                }
            }
        }

        return (maxProduct > 0) ? maxProduct : -1;
    }

    public static void main(String[] args)
    {
        // Example
        int N = 5;
        int[][] Edges
            = { { 1, 2 }, { 2, 5 }, { 3, 5 }, { 4, 5 },
                { 1, 2 }, { 2, 3 }, { 3, 4 } };
        int[] Weight = { 1, 1, 1, 1, 2, 2, 2 };
        System.out.println(
            maximumProduct(N, Edges, Weight)); // Output: 20
    }
}

// This code is contributed by Shivam Gupta