Find all unique pairs of maximum and second maximum elements over all sub-arrays in O(NlogN) - GeeksforGeeks

10 Dec, 2021
Let represent the ordered pair of the second maximum and the maximum element of an array respectively. We need to find all such unique pairs overall contiguous sub-arrays of a given array.
Examples:  
Input: Arr = [ 1, 2, 3, 4, 5 ] Output: (1, 2) (2, 3) (3, 4) (4, 5)
Input: Arr = [ 1, 1, 2 ] Output: (1, 1) (1, 2)
Input: Arr = [ 1, 2, 6, 4, 5 ] Output: (1, 2) (2, 6) (4, 5) (4, 6) (5, 6)  
Brute Force Approach: 
A simple way to solve this problem would be to scan each sub-array and find the maximum and second maximum element in that sub-array
This can be done in time
Then we can insert each pair in a set to ensure duplicates are removed, and then print them
Each insertion operation costs , pushing the final complexity to 
C++14
Java
Python3
Javascript
// C++ implementation#include <bits/stdc++.h>using namespace std; // Function to return the set of pairsset<pair<int, int> > pairs(vector<int>& arr){    set<pair<int, int> > pairs;     // find all subarrays    for (int i = 0; i < arr.size() - 1; ++i) {        int maximum = max(arr[i], arr[i + 1]),            secondmax = min(arr[i], arr[i + 1]);         for (int j = i + 1; j < arr.size(); ++j) {            // update max and second max            if (arr[j] > maximum) {                secondmax = maximum;                maximum = arr[j];            }            if (arr[j] < maximum && arr[j] > secondmax) {                secondmax = arr[j];            }             // insert a pair in set            pairs.insert(make_pair(secondmax, maximum));        }    }    return pairs;} int main(){    vector<int> vec = { 1, 2, 6, 4, 5 };     set<pair<int, int> > st = pairs(vec);    cout << "Total Number of valid pairs is :"         << (int)st.size() << "\n";    for (auto& x : st) {        cout << "(" << x.first << ", " << x.second << ") ";    }    return 0;}
// Java implementationimport java.util.HashSet;import java.util.Set; class Pair implements Comparable<Pair> {    int first, second;     public Pair(int first, int second)    {        this.first = first;        this.second = second;    }     @Override public int hashCode()    {        return 31 * first + second;    }     public boolean equals(Object p)    {        Pair pair = (Pair)p;         if (this.first != pair.first)            return false;         return this.second == pair.second;    }     @Override public int compareTo(Pair p)    {        if (this.first == p.first) {            return this.second - p.second;        }        return this.first - p.first;    }} class GFG {     // Function to return the set of pairs    static Set<Pair> pairs(int[] arr)    {        Set<Pair> pairs = new HashSet<>();         // Find all subarrays        for (int i = 0; i < arr.length - 1; ++i) {            int maximum = Math.max(arr[i], arr[i + 1]),                secondmax = Math.min(arr[i], arr[i + 1]);             for (int j = i + 1; j < arr.length; ++j) {                 // Update max and second max                if (arr[j] > maximum) {                    secondmax = maximum;                    maximum = arr[j];                }                if (arr[j] < maximum                    && arr[j] > secondmax) {                    secondmax = arr[j];                }                 // Insert a pair in set                pairs.add(new Pair(secondmax, maximum));            }        }        return pairs;    }     // Driver Code    public static void main(String[] args)    {        int[] vec = { 1, 2, 6, 4, 5 };         Set<Pair> st = pairs(vec);        System.out.println("Total Number of "                           + "valid pairs is :"                           + st.size());         for (Pair x : st) {            System.out.printf("(%d, %d)\n", x.first,                              x.second);        }    }} // This code is contributed by sanjeev2552
# python3 implementation # Function to return the set of pairsdef SetofPairs(arr):     pairs = set()    n = len(arr)     # length of array         # find all subarrays    for i in range(n - 1):        maximum = max(arr[i], arr[i + 1])        secondmax = min(arr[i], arr[i + 1])        for j in range(i + 1, n):             # update max and second max            if (arr[j] > maximum):                secondmax = maximum                maximum = arr[j]            if (arr[j] < maximum and arr[j] > secondmax):                secondmax = arr[j]             # add a pair in set            pairs.add((secondmax, maximum))    return pairs # Driver codeif __name__ == "__main__":     vec = [1, 2, 6, 4, 5]    st = SetofPairs(vec)    print("Total Number of valid pairs is :", len(st))     for x in st:        print(x, end = " ")         # This code is contributed by sunilsoni10220001022000.
<script> // JavaScript implementation // Function to return the set of pairsfunction pairs(arr){    var pairs = new Set();     // find all subarrays    for (var i = 0; i < arr.length - 1; ++i) {        var maximum = Math.max(arr[i], arr[i + 1]),            secondmax = Math.min(arr[i], arr[i + 1]);         for (var j = i + 1; j < arr.length; ++j) {            // update max and second max            if (arr[j] > maximum) {                secondmax = maximum;                maximum = arr[j];            }            if (arr[j] < maximum && arr[j] > secondmax) {                secondmax = arr[j];            }             // insert a pair in set            pairs.add([secondmax, maximum].toString());        }    }    return pairs;} var vec = [1, 2, 6, 4, 5 ];var st = pairs(vec);document.write( "Total Number of valid pairs is :" +st.size + "<br>");[...st].sort().forEach(x => {    x = x.split(',');    document.write( "(" + x[0] + ", " + x[1] + ") ")}) </script>
Output: 
Total Number of valid pairs is :5
(1, 2) (2, 6) (4, 5) (4, 6) (5, 6)
Complexity Analysis: 
Time Complexity: O(N^2 log(N)). Insertion in set takes log N time. There can be at most N^2 sub-arrays. So the time Complexity is O(N^2 log N).
Auxiliary Space: O(n^2). As extra space is required to store the elements in a set.
Efficient Approach: 
It could bring down the complexity of finding pairs to by observing that an element can form pairs with elements only till the closest element to the right which is greater than .
To see why this holds, consider = in the next example.
 Arr = {1, 4, 5, 3, 2, 1}
It could see that is the nearest element to the right which is greater than . forms a pair considering the sub-array .
Other sub-arrays, that start with must include . Considering one of them, if another element exists in the sub-array, then will be the pair for that sub-array.
Else either will be formed or will be formed, where is the max element to the right of in the sub-array.
In any cases, cannot form a pair with any element to the right of .
Using this observation, we can implement the logic using stack which brings down the pair generation complexity to .
Each pair can be inserted into a set for eliminating duplicates, giving a final time complexity of 
Below is the implementation of the above approach: 
C++
Java
Python3
// C++ implementation of the above approach#include <bits/stdc++.h>using namespace std; // Function to return the set of pairsset<pair<int, int>>     pairs(vector<int>& arr){    stack<int> st;    set<pair<int, int>> pairs;     // Push first element into stack    st.push(arr[0]);     // For each element 'X' in arr,    // pop the stack while top Element    // is smaller than 'X' and form a pair.    // If the stack is not empty after    // the previous operation, create    // a pair. Push X into the stack.     for (int i = 1; i < arr.size(); ++i) {        while (!st.empty() &&                arr[i] > st.top()) {            pairs.insert(make_pair(st.top(),                                    arr[i]));            st.pop();        }        if (!st.empty()) {            pairs.insert(make_pair(min(st.top(),                                       arr[i]),                                   max(st.top(),                                      arr[i])));        }        st.push(arr[i]);    }    return pairs;} int main(){    vector<int> vec = { 1, 2, 6, 4, 5 };     set<pair<int, int> > st = pairs(vec);    cout << "Total Number of valid pairs is :"                   << (int)st.size() << "\n";    for (auto& x : st) {        cout << "(" << x.first << ", "                       << x.second << ") ";    }    return 0;}
// Java implementation of the above approachimport java.util.*; class GFG{     static class pair{    int first, second;         public pair(int first, int second)     {        this.first = first;        this.second = second;    }         @Override    public int hashCode()    {        final int prime = 31;        int result = 1;        result = prime * result + first;        result = prime * result + second;        return result;    }         @Override    public boolean equals(Object obj)    {        if (this == obj)            return true;        if (obj == null)            return false;        if (getClass() != obj.getClass())            return false;                     pair other = (pair) obj;        if (first != other.first)            return false;        if (second != other.second)            return false;        return true;    } } // Function to return the set of pairsstatic HashSet<pair> pairs(int[] arr){    Stack<Integer> st = new Stack<Integer>();    HashSet<pair> pairs = new HashSet<pair>();         // Push first element into stack    st.add(arr[0]);         // For each element 'X' in arr,    // pop the stack while top Element    // is smaller than 'X' and form a pair.    // If the stack is not empty after    // the previous operation, create    // a pair. Push X into the stack.    for(int i = 1; i < arr.length; ++i)    {        while (!st.isEmpty() && arr[i] > st.peek())        {            pairs.add(new pair(st.peek(),                               arr[i]));            st.pop();        }        if (!st.isEmpty())        {            pairs.add(new pair(Math.min(st.peek(),                                        arr[i]),                               Math.max(st.peek(),                                        arr[i])));        }        st.add(arr[i]);    }    return pairs;} // Driver codepublic static void main(String[] args){    int [] vec = { 1, 2, 6, 4, 5 };     HashSet<pair> st = pairs(vec);    System.out.print("Total Number of valid pairs is :"  +                     (int)st.size() + "\n");    for(pair x : st)    {        System.out.print("(" +  x.first+ ", " +                                x.second + ") ");    }}} // This code is contributed by 29AjayKumar
# Python3 implementation of the above approach # Function to return the set of pairsdef pairs(arr) :     st = [];    pairs = [];     # Push first element into stack    st.append(arr[0]);     # For each element 'X' in arr,    # pop the stack while top Element    # is smaller than 'X' and form a pair.    # If the stack is not empty after    # the previous operation, create    # a pair. Push X into the stack.    for i in range(1, len(arr) ) :        while len(st) != 0 and arr[i] > st[-1] :            pairs.append((st[-1], arr[i]));            st.pop();             if len(st) != 0 :            pairs.append((min(st[-1], arr[i]),                        max(st[-1], arr[i])));                 st.append(arr[i]);         return pairs; # Driver codeif __name__ == "__main__" :     vec = [ 1, 2, 6, 4, 5 ];    st = pairs(vec);    print("Total Number of valid pairs is :",len(st));         for x in st :        print("(" ,x[0], ", ",x[1], ")",end=" "); # This code is contributed by AnkitRai01
Total Number of valid pairs is :5
(1, 2) (2, 6) (4, 5) (4, 6) (5, 6)
 
Complexity Analysis: 
Time Complexity: O(N log(N)). Each pair can be inserted into a set for eliminating duplicates, giving a final time complexity of O(N log N)
Auxiliary Space: O(N). As extra space is required to store the elements in a set.
 
ankthon
andrew1234
sanjeev2552
sunils0ni
itsok
29AjayKumar
subarray
Arrays
Stack
Arrays
Stack
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Multidimensional Arrays in Java
Introduction to Arrays
Python | Using 2D arrays/lists the right way
Linked List vs Array
Given an array A[] and a number x, check for pair in A[] with sum as x (aka Two Sum)
Stack in Python
Stack Class in Java
Program for Tower of Hanoi
Check for Balanced Brackets in an expression (well-formedness) using Stack
Stack | Set 2 (Infix to Postfix)