Maximize count of increasing triplets from any permutation of given 3 Arrays
Last Updated :
20 Nov, 2021
Given three arrays X[], Y[], and Z[] each consisting of N integers, the task is to find the maximum number of triplets (X[i], Y[i], Z[i]) such that (X[i] < Y[i] < Z[i]) for any permutation of the three arrays.
Examples:
Input: X = {9, 6, 14, 1, 8}, Y = {2, 10, 3, 12, 11}, Z = {15, 13, 5, 7, 4}
Output: 3
Explanation:
After rearranging the arrays X[], Y[] and Z[] as {1, 6, 8, 9, 14}, {3, 2, 10, 12, 11}, and {4, 7, 15, 13, 5} respectively. The increasing triplets are {1, 3, 4}, {8, 10, 15} and {9, 12, 13}.
Therefore, the total count of such triplets is 3.
Input: X = {1, 2, 3, 4}, Y = {5, 6, 7, 8}, Z = {9, 10, 11, 12}
Output: 4
Naive Approach: The given problem can be solved by generating all possible combinations of triplets of the three arrays and count those triplets that satisfy the given conditions. After checking for all the permutations, print the total count of triplets obtained.
Time Complexity: O(N*(N!)3)
Auxiliary Space: O(1)
Efficient Approach: The given problem can be solve by using the Greedy Approach, the idea is to sort the given array X[] and then for finding the triplets choose those elements in the array Y[] and Z[] that forms increasing triplets for every elements of the array and this idea can be implemented using the priority queue. Follow the steps below to solve the problem:
- Sort the array X[] in increasing order.
- Initialize two priority queues, say PQY and PQZ implementing MinHeap for the array Y[] and Z[] respectively.
- Store all the element of the array Y[] in the PQY.
- Store all the element of the array Z[] in the PQZ.
- Traverse the array X[] and perform the following steps:
- After completing the above steps, print the value of count as the resultant maximum count of triplets.
Below is the implementation of the above approach:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to find the number of triplets
// that are in increasing order from the
// given three arrays after rearranging
int countTriplet(int arr1[], int arr2[],
int arr3[], int N)
{
// Sort the given array arr[]
sort(arr1, arr1 + N);
// Initializing priority queues
priority_queue<int, vector<int>,
greater<int> >
Y;
priority_queue<int, vector<int>,
greater<int> >
Z;
// Push array elements arr2[i] in Y
for (int i = 0; i < N; i++) {
Y.push(arr2[i]);
}
// Push array elements arr3[i] in Y
for (int i = 0; i < N; i++) {
Z.push(arr3[i]);
}
int x, y, z;
int ans = 0;
// Traverse the array arr1[]
for (int i = 0; i < N; i++) {
x = arr1[i];
while (!Y.empty()
&& Y.top() <= x)
Y.pop();
// If Y is empty then there is
// no more triplets possible
if (Y.empty())
break;
y = Y.top();
Y.pop();
while (!Z.empty()
&& Z.top() <= y)
Z.pop();
// If Z is empty then there is
// no more triplets possible
if (Z.empty())
break;
z = Z.top();
Z.pop();
// Increment the triplets count
++ans;
}
// Return the maximum count of triplets
return ans;
}
// Driver Code
int main()
{
int X[] = { 9, 6, 14, 1, 8 };
int Y[] = { 2, 10, 3, 12, 11 };
int Z[] = { 15, 13, 5, 7, 4 };
int N = sizeof(X) / sizeof(X[0]);
cout << countTriplet(X, Y, Z, N);
return 0;
}
// Java program for the above approach
import java.util.*;
public class Main
{
// Function to find the number of triplets
// that are in increasing order from the
// given three arrays after rearranging
static int countTriplet(int[] arr1, int[] arr2,
int[] arr3, int N)
{
// Sort the given array arr[]
Arrays.sort(arr1);
// Initializing priority queues
Vector<Integer> Y = new Vector<Integer>();
Vector<Integer> Z = new Vector<Integer>();
// Push array elements arr2[i] in Y
for (int i = 0; i < N; i++) {
Y.add(arr2[i]);
}
// Push array elements arr3[i] in Y
for (int i = 0; i < N; i++) {
Z.add(arr3[i]);
}
Collections.sort(Y);
Collections.sort(Z);
int x, y, z;
int ans = 0;
// Traverse the array arr1[]
for (int i = 0; i < N; i++) {
x = arr1[i];
while (Y.size() > 0 && Y.get(0) <= x)
Y.remove(0);
// If Y is empty then there is
// no more triplets possible
if (Y.size() == 0)
break;
y = Y.get(0);
Y.remove(0);
while (Z.size() > 0 && Z.get(0) <= y)
Z.remove(0);
// If Z is empty then there is
// no more triplets possible
if (Z.size() == 0)
break;
z = Z.get(0);
Z.remove(0);
// Increment the triplets count
++ans;
}
// Return the maximum count of triplets
return ans;
}
public static void main(String[] args) {
int[] X = { 9, 6, 14, 1, 8 };
int[] Y = { 2, 10, 3, 12, 11 };
int[] Z = { 15, 13, 5, 7, 4 };
int N = X.length;
System.out.println(countTriplet(X, Y, Z, N));
}
}
// This code is contributed by suresh07.
# Python program for the above approach
from queue import PriorityQueue
# Function to find the number of triplets
# that are in increasing order from the
# given three arrays after rearranging
def countTriplet(arr1, arr2, arr3, N):
# Sort the given array arr[]
arr1.sort();
# Initializing priority queues
Y = PriorityQueue();
Z = PriorityQueue();
# Push array elements arr2[i] in Y
for i in range(N):
Y.put(arr2[i]);
# Push array elements arr3[i] in Y
for i in range(N):
Z.put(arr3[i]);
x = 0
y = 0
z = 0
ans = 0;
# Traverse the array arr1[]
for i in range(N):
x = arr1[i];
while (not Y.empty() and Y.queue[0] <= x):
Y.get();
# If Y is empty then there is
# no more triplets possible
if (Y.empty()):
break;
y = Y.queue[0];
Y.get()
while (not Z.empty() and Z.queue[0] <= y):
Z.get();
# If Z is empty then there is
# no more triplets possible
if (Z.empty()):
break;
z = Z.queue[0];
Z.get();
# Increment the triplets count
ans += 1;
# Return the maximum count of triplets
return ans;
# Driver Code
X = [ 9, 6, 14, 1, 8 ];
Y = [ 2, 10, 3, 12, 11 ];
Z = [ 15, 13, 5, 7, 4 ];
N = len(X);
print(countTriplet(X, Y, Z, N));
# This code is contributed by _saurabh_jaiswal.
// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG {
// Function to find the number of triplets
// that are in increasing order from the
// given three arrays after rearranging
static int countTriplet(int[] arr1, int[] arr2,
int[] arr3, int N)
{
// Sort the given array arr[]
Array.Sort(arr1);
// Initializing priority queues
List<int> Y = new List<int>();
List<int> Z = new List<int>();
// Push array elements arr2[i] in Y
for (int i = 0; i < N; i++) {
Y.Add(arr2[i]);
}
// Push array elements arr3[i] in Y
for (int i = 0; i < N; i++) {
Z.Add(arr3[i]);
}
Y.Sort();
Z.Sort();
int x, y, z;
int ans = 0;
// Traverse the array arr1[]
for (int i = 0; i < N; i++) {
x = arr1[i];
while (Y.Count > 0
&& Y[0] <= x)
Y.RemoveAt(0);
// If Y is empty then there is
// no more triplets possible
if (Y.Count == 0)
break;
y = Y[0];
Y.RemoveAt(0);
while (Z.Count > 0
&& Z[0] <= y)
Z.RemoveAt(0);
// If Z is empty then there is
// no more triplets possible
if (Z.Count == 0)
break;
z = Z[0];
Z.RemoveAt(0);
// Increment the triplets count
++ans;
}
// Return the maximum count of triplets
return ans;
}
static void Main() {
int[] X = { 9, 6, 14, 1, 8 };
int[] Y = { 2, 10, 3, 12, 11 };
int[] Z = { 15, 13, 5, 7, 4 };
int N = X.Length;
Console.Write(countTriplet(X, Y, Z, N));
}
}
// This code is contributed by divyeshrabadiya07.
<script>
// Javascript program for the above approach
// Function to find the number of triplets
// that are in increasing order from the
// given three arrays after rearranging
function countTriplet(arr1, arr2, arr3, N)
{
// Sort the given array arr[]
arr1.sort(function(a, b){return a - b});
// Initializing priority queues
Y = [];
Z = [];
// Push array elements arr2[i] in Y
for (let i = 0; i < N; i++) {
Y.push(arr2[i]);
}
// Push array elements arr3[i] in Y
for (let i = 0; i < N; i++) {
Z.push(arr3[i]);
}
Y.sort(function(a, b){return a - b});
Z.sort(function(a, b){return a - b});
let x, y, z;
let ans = 0;
// Traverse the array arr1[]
for (let i = 0; i < N; i++) {
x = arr1[i];
while (Y.length > 0 && Y[0] <= x)
Y.shift();
// If Y is empty then there is
// no more triplets possible
if (Y.Count == 0)
break;
y = Y[0];
Y.shift();
while (Z.length > 0 && Z[0] <= y)
Z.shift();
// If Z is empty then there is
// no more triplets possible
if (Z.length == 0)
break;
z = Z[0];
Z.shift();
// Increment the triplets count
++ans;
}
// Return the maximum count of triplets
return ans;
}
X = [ 9, 6, 14, 1, 8 ];
Y = [ 2, 10, 3, 12, 11 ];
Z = [ 15, 13, 5, 7, 4 ];
N = X.length;
document.write(countTriplet(X, Y, Z, N));
// This code is contributed by decode2207.
</script>
Time Complexity: O(N * log N)
Auxiliary Space: O(N)
Similar Reads
Count of permutations of an Array having maximum MEXs sum of prefix arrays Given an array arr of size N, the task is to find the number of its permutations such that the sum of MEXs of its prefix arrays is maximum. Note: MEX of a set of integers is defined as the smallest non-negative integer that does not belong to this set. Example: Input: arr[] = {1, 0, 1}Output: 2Expla
10 min read
Count of triplets whose indices and element at that indices are in increasing order Given an array arr[] consisting of N integers, the task is to find the number of triplets whose indices and elements at that indices are in increasing order. Examples: Input: arr[] = {1, 2, 4, 3}Output: 2Explanation: There are 2 possible triplets in the given array such that the elements are in incr
12 min read
Find the Number of Permutations that satisfy the given condition in an array Given an array arr[] of size N, the task is to find the number of permutations in the array that follows the given condition: If K is the maximum element in the array, then the elements before K in the array should be in the ascending order and the elements after K in the array should be in the desc
12 min read
Maximum sum of increasing order elements from n arrays Given n arrays of size m each. Find the maximum sum obtained by selecting a number from each array such that the elements selected from the i-th array are more than the element selected from (i-1)-th array. If maximum sum cannot be obtained then return 0.Examples: Input : arr[][] = {{1, 7, 3, 4}, {4
13 min read
Count of triplets of numbers 1 to N such that middle element is always largest Given an integer N, the task is to count the number of ways to arrange triplets (a, b, c) within [1, N] in such a way such that the middle element is always greater than left and right elements. Example: Input: N = 4 Output: 8 Explanation For the given input N = 4 number of possible triplets are:{1,
4 min read