Related Articles

# Maximum element in connected component of given node for Q queries

• Difficulty Level : Hard
• Last Updated : 05 Oct, 2021

Given an array of pairs arr[][] of length N, and an array queries[] of length M, and an integer R, where queries[i] contain an integer from 1 to R, the task for every queries[i] is to find the maximum element of the connected components of the node with value queries[i].

Note: Initially every integer from 1 to R belongs to the distinct set.

Examples:

Input: R = 5, arr = {{1, 2}, {2, 3}, {4, 5}}, queries[] = {2, 4, 1, 3}
Output: 3 5 3 3
Explanation: After making the sets from the arr[] pairs, {1, 2, 3}, {4, 5}
For the first query: 2 belongs to the set {1, 2, 3} and the maximum element is 3
For the second query: 4 belongs to the set {4, 5} and the maximum element is 5
For the third query: 1 belongs to the set {1, 2, 3} and the maximum element is 3
For the fourth query: 3 belongs to the set {1, 2, 3} and the maximum element is 3

Input: R = 6, arr = {{1, 3}, {2, 4}}, queries = {2, 5, 6, 1}
Output: 4 5 6 3

Approach: The given problem can be solved using the Disjoint Set Union. Initially, all the elements are in different sets, process the arr[] and do union operation on the given pairs and in union update, the maximum value for each set in the array, say maxValue[] value for the parent element. For each query perform the find operation and for the returned parent element find the maxParent[parent]. Follow the steps below to solve the problem:

• Initialize a vector maxValue[] to find the maximum element of every set.
• Initialize the vectors parent(R+1), rank(R+1, 0), maxValue(R+1).
• Iterate over the range [1, R+1) using the variable i and set the value of parent[i] and maxValue[i] as i.
• Iterate over the range [1, N-1] using the variable i and call for function operation Union(parent, rank, maxValue, arr[i].first, arr[i].second).
• Iterate over the range [1, M-1] using the variable i and perform the following steps:
• call for function operation Find(parent, queries[i]).
• Print the value of maxValue[i] as the resultant maximum element.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to perform the find operation``// to find the parent of a disjoint set``int` `Find(vector<``int``>& parent, ``int` `a)``{``    ``return` `parent[a] = (parent[a] == a)``                           ``? a``                           ``: (Find(parent, parent[a]));``}` `// FUnction to perform union operation``// of disjoint set union``void` `Union(vector<``int``>& parent,``           ``vector<``int``>& rank,``           ``vector<``int``>& maxValue,``           ``int` `a, ``int` `b)``{` `    ``a = Find(parent, a);``    ``b = Find(parent, b);` `    ``if` `(a == b)``        ``return``;` `    ``// If the rank are the same``    ``if` `(rank[a] == rank[b]) {``        ``rank[a]++;``    ``}` `    ``if` `(rank[a] < rank[b]) {``        ``int` `temp = a;``        ``a = b;``        ``b = temp;``    ``}` `    ``parent[b] = a;` `    ``// Update the maximum value``    ``maxValue[a] = max(maxValue[a],``                      ``maxValue[b]);``}` `// Function to find the maximum element``// of the set which belongs to the``// element queries[i]``void` `findMaxValueOfSet(``    ``vector >& arr,``    ``vector<``int``>& queries, ``int` `R, ``int` `N,``    ``int` `M)``{` `    ``// Stores the parent elements``    ``// of the sets``    ``vector<``int``> parent(R + 1);` `    ``// Stores the rank of the sets``    ``vector<``int``> rank(R + 1, 0);` `    ``// Stores the maxValue of the sets``    ``vector<``int``> maxValue(R + 1);` `    ``for` `(``int` `i = 1; i < R + 1; i++) {` `        ``// Update parent[i] and``        ``// maxValue[i] to i``        ``parent[i] = maxValue[i] = i;``    ``}` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Add arr[i].first and``        ``// arr[i].second elements to``        ``// the same set``        ``Union(parent, rank, maxValue,``              ``arr[i].first,``              ``arr[i].second);``    ``}` `    ``for` `(``int` `i = 0; i < M; i++) {` `        ``// Find the parent element of``        ``// the element queries[i]``        ``int` `P = Find(parent, queries[i]);` `        ``// Print the maximum value``        ``// of the set which belongs``        ``// to the element P``        ``cout << maxValue[P] << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{` `    ``int` `R = 5;``    ``vector > arr{ { 1, 2 },``                                 ``{ 2, 3 },``                                 ``{ 4, 5 } };``    ``vector<``int``> queries{ 2, 4, 1, 3 };``    ``int` `N = arr.size();``    ``int` `M = queries.size();` `    ``findMaxValueOfSet(arr, queries, R, N, M);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``class` `GFG{` `// Function to perform the find operation``// to find the parent of a disjoint set``static` `int` `Find(``int` `[] parent, ``int` `a)``{``    ``return` `parent[a] = (parent[a] == a)``                           ``? a``                           ``: (Find(parent, parent[a]));``}` `// FUnction to perform union operation``// of disjoint set union``static` `void` `Union(``int` `[] parent,``           ``int` `[] rank,``           ``int` `[] maxValue,``           ``int` `a, ``int` `b)``{` `    ``a = Find(parent, a);``    ``b = Find(parent, b);` `    ``if` `(a == b)``        ``return``;` `    ``// If the rank are the same``    ``if` `(rank[a] == rank[b]) {``        ``rank[a]++;``    ``}` `    ``if` `(rank[a] < rank[b]) {``        ``int` `temp = a;``        ``a = b;``        ``b = temp;``    ``}` `    ``parent[b] = a;` `    ``// Update the maximum value``    ``maxValue[a] = Math.max(maxValue[a],``                      ``maxValue[b]);``}` `// Function to find the maximum element``// of the set which belongs to the``// element queries[i]``static` `void` `findMaxValueOfSet(``    ``int``[][]  arr,``    ``int` `[] queries, ``int` `R, ``int` `N,``    ``int` `M)``{` `    ``// Stores the parent elements``    ``// of the sets``    ``int` `[] parent = ``new` `int``[R + ``1``];` `    ``// Stores the rank of the sets``    ``int` `[] rank = ``new` `int``[R + ``1``];` `    ``// Stores the maxValue of the sets``    ``int` `[] maxValue = ``new` `int``[R + ``1``];` `    ``for` `(``int` `i = ``1``; i < R + ``1``; i++) {` `        ``// Update parent[i] and``        ``// maxValue[i] to i``        ``parent[i] = maxValue[i] = i;``    ``}` `    ``for` `(``int` `i = ``0``; i < N; i++) {` `        ``// Add arr[i] and``        ``// arr[i] elements to``        ``// the same set``        ``Union(parent, rank, maxValue,``              ``arr[i][``0``],``              ``arr[i][``1``]);``    ``}` `    ``for` `(``int` `i = ``0``; i < M; i++) {` `        ``// Find the parent element of``        ``// the element queries[i]``        ``int` `P = Find(parent, queries[i]);` `        ``// Print the maximum value``        ``// of the set which belongs``        ``// to the element P``        ``System.out.print(maxValue[P]+ ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `R = ``5``;``    ``int``[][]  arr ={ { ``1``, ``2` `},``                                 ``{ ``2``, ``3` `},``                                 ``{ ``4``, ``5` `} };``    ``int` `[] queries = { ``2``, ``4``, ``1``, ``3` `};``    ``int` `N = arr.length;``    ``int` `M = queries.length;` `    ``findMaxValueOfSet(arr, queries, R, N, M);``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python 3 program for the above approach` `# Function to perform the find operation``# to find the parent of a disjoint set``def` `Find(parent, a):``    ``if``(parent[parent[a]]!``=``parent[a]):``        ``parent[a]``=``findParent(parent,parent[a])``    ``return` `parent[a]``    ``#return parent[a] = a if (parent[a] == a) else Find(parent, parent[a])` `# FUnction to perform union operation``# of disjoint set union``def` `Union(parent, rank, maxValue, a, b):``    ``a ``=` `Find(parent, a)``    ``b ``=` `Find(parent, b)` `    ``if` `(a ``=``=` `b):``        ``return` `    ``# If the rank are the same``    ``if` `(rank[a] ``=``=` `rank[b]):``        ``rank[a] ``+``=` `1` `    ``if` `(rank[a] < rank[b]):``        ``temp ``=` `a``        ``a ``=` `b``        ``b ``=` `temp` `    ``parent[b] ``=` `a` `    ``# Update the maximum value``    ``maxValue[a] ``=` `max``(maxValue[a],maxValue[b])` `# Function to find the maximum element``# of the set which belongs to the``# element queries[i]``def` `findMaxValueOfSet(arr,queries, R, N, M):``    ``# Stores the parent elements``    ``# of the sets``    ``parent ``=` `[``1` `for` `i ``in` `range``(R``+``1``)]` `    ``# Stores the rank of the sets``    ``rank ``=` `[``0` `for` `i ``in` `range``(R``+``1``)]` `    ``# Stores the maxValue of the sets``    ``maxValue ``=` `[``0` `for` `i ``in` `range``(R ``+` `1``)]` `    ``for` `i ``in` `range``(``1``,R ``+` `1``,``1``):` `        ``# Update parent[i] and``        ``# maxValue[i] to i``        ``parent[i] ``=` `maxValue[i] ``=` `i` `    ``for` `i ``in` `range``(N):``        ``# Add arr[i].first and``        ``# arr[i].second elements to``        ``# the same set``        ``Union(parent, rank, maxValue, arr[i][``0``],arr[i][``1``])` `    ``for` `i ``in` `range``(M):``        ``# Find the parent element of``        ``# the element queries[i]``        ``P ``=` `Find(parent, queries[i])` `        ``# Print the maximum value``        ``# of the set which belongs``        ``# to the element P``        ``print``(maxValue[P],end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``R ``=` `5``    ``arr ``=` `[[``1``, ``2``],``           ``[``2``, ``3``],``           ``[``4``, ``5``]];``    ``queries ``=`  `[``2``, ``4``, ``1``, ``3``]``    ``N ``=` `len``(arr)``    ``M ``=` `len``(queries)` `    ``findMaxValueOfSet(arr, queries, R, N, M)``    ` `    ``# This code is contributed by SURENDRA_GANGWAR.`

## Javascript

 ``
Output:
`3 5 3 3`

Time Complexity: O(N*log M)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up