Open In App
Related Articles

Maximize elements using another array

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Given two arrays with size n, maximize the first array by using the elements from the second array such that the new array formed contains n greatest but unique elements of both the arrays giving the second array priority (All elements of second array appear before first array). The order of appearance of elements is kept same in output as in input.

Examples:

Input : arr1[] = {2, 4, 3} 
arr2[] = {5, 6, 1} 
Output : 5 6 4 
As 5, 6 and 4 are maximum elements from two arrays giving second array higher priority. Order of elements is same in output as in input.

Input : arr1[] = {7, 4, 8, 0, 1} 
arr2[] = {9, 7, 2, 3, 6} 
Output : 9 7 6 4 8

Approach : We create an auxiliary array of size 2*n and store the elements of 2nd array in auxiliary array, and then we will store elements of 1st array in it. After that we will sort auxiliary array in decreasing order. To keep the order of elements according to input arrays we will use hash table. We will store 1st n largest unique elements of auxiliary array in hash table. Now we traverse the second array and store that elements of second array in auxiliary array that are present in hash table. Similarly we will traverse first array and store the elements that are present in hash table. In this way we get n unique and largest elements from both the arrays in auxiliary array while keeping the order of appearance of elements same.

Below is the implementation of above approach :

C++

// C++ program to print the maximum elements
// giving second array higher priority
#include <bits/stdc++.h>
using namespace std;
 
// Compare function used to sort array
// in decreasing order
bool compare(int a, int b)
{
    return a > b;
}
 
// Function to maximize array elements
void maximizeArray(int arr1[], int arr2[],
                                   int n)
{
    // auxiliary array arr3 to store
    // elements of arr1 & arr2
    int arr3[2*n], k = 0;
    for (int i = 0; i < n; i++)
        arr3[k++] = arr1[i];
    for (int i = 0; i < n; i++)
        arr3[k++] = arr2[i];
 
    // hash table to store n largest
    // unique elements
    unordered_set<int> hash;
 
    // sorting arr3 in decreasing order
    sort(arr3, arr3 + 2 * n, compare);
 
    // finding n largest unique elements
    // from arr3 and storing in hash
    int i = 0;
    while (hash.size() != n) {
 
        // if arr3 element not present in hash,
        // then store this element in hash
        if (hash.find(arr3[i]) == hash.end())
            hash.insert(arr3[i]);
         
        i++;
    }
 
    // store that elements of arr2 in arr3
    // that are present in hash
    k = 0;
    for (int i = 0; i < n; i++) {
 
        // if arr2 element is present in hash,
        // store it in arr3
        if (hash.find(arr2[i]) != hash.end()) {
            arr3[k++] = arr2[i];
            hash.erase(arr2[i]);
        }
    }
 
    // store that elements of arr1 in arr3
    // that are present in hash
    for (int i = 0; i < n; i++) {
 
        // if arr1 element is present in hash,
        // store it in arr3
        if (hash.find(arr1[i]) != hash.end()) {
            arr3[k++] = arr1[i];
            hash.erase(arr1[i]);
        }
    }
 
    // copying 1st n elements of arr3 to arr1
    for (int i = 0; i < n; i++)
        arr1[i] = arr3[i];   
}
 
// Function to print array elements
void printArray(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";   
    cout << endl;
}
 
// Driver Code
int main()
{
    int array1[] = { 7, 4, 8, 0, 1 };
    int array2[] = { 9, 7, 2, 3, 6 };
    int size = sizeof(array1) / sizeof(array1[0]);
    maximizeArray(array1, array2, size);
    printArray(array1, size);
}

                    

Java

// Java program to print the maximum elements
// giving second array higher priority
import java.util.*;
 
class GFG
{
 
// Function to maximize array elements
static void maximizeArray(int[] arr1,int[] arr2)
{
    // auxiliary array arr3 to store
    // elements of arr1 & arr2
    int arr3[] = new int[10];
    for(int i = 0; i < arr3.length; i++)
    {
        //arr2 has high priority
        arr3[i] = 0;
    }
     
    // Arraylist to store n largest
    // unique elements
    ArrayList<Integer> al = new ArrayList<Integer>();
     
    for(int i = 0; i < arr2.length; i++)
    {
        if(arr3[arr2[i]] == 0)
        {
            // to avoid repetition of digits of arr2 in arr3
            arr3[arr2[i]] = 2;
             
            // simultaneously setting arraylist to
            // preserve order of arr2 and arr3
            al.add(arr2[i]);
        }
    }
     
    for(int i = 0; i < arr1.length; i++)
    {
        if(arr3[arr1[i]] == 0)
        {
            // if digit is already present in arr2
            // then priority is arr2
            arr3[arr1[i]] = 1;
             
            // simultaneously setting arraylist to
            // preserve order of arr1
            al.add(arr1[i]);
        }
    }
 
    // to get only highest n elements(arr2+arr1)
    // and remove others from arraylist
    int count = 0;
    for(int j = 9; j >= 0; j--)
    {
        if(count < arr1.length &
          (arr3[j] == 2 || arr3[j] == 1))
        {
            // to not allow those elements
            // which are absent in both arrays
            count++;
        }
        else
        {
            al.remove(Integer.valueOf(j));
        }
    }
 
    int i = 0;
    for(int x:al)
    {
        arr1[i++] = x;
    }
}
 
// Function to print array elements
static void printArray(int[] arr)
{
    for(int x:arr)
    {
        System.out.print(x + " ");
    }
}
 
// Driver Code
public static void main(String args[])
{
    int arr1[] = {7, 4, 8, 0, 1};
    int arr2[] = {9, 7, 2, 3, 6};
    maximizeArray(arr1,arr2);
    printArray(arr1);
}
}
 
// This code is contributed by KhwajaBilkhis

                    

Python3

# Python3 program to print the maximum elements
# giving second array higher priority
 
# Function to maximize array elements
def maximizeArray(arr1, arr2, n):
     
    # Auxiliary array arr3 to store
    # elements of arr1 & arr2
    arr3 = [0] * (2 * n)
    k = 0
     
    for i in range(n):
        arr3[k] = arr1[i]
        k += 1
         
    for i in range(n):
        arr3[k] = arr2[i]
        k += 1
 
    # Hash table to store n largest
    # unique elements
    hash = {}
 
    # Sorting arr3 in decreasing order
    arr3 = sorted(arr3)
    arr3 = arr3[::-1]
 
    # Finding n largest unique elements
    # from arr3 and storing in hash
    i = 0
    while (len(hash) != n):
 
        # If arr3 element not present in hash,
        # then store this element in hash
        if (arr3[i] not in hash):
            hash[arr3[i]] = 1
 
        i += 1
 
    # Store that elements of arr2 in arr3
    # that are present in hash
    k = 0
    for i in range(n):
 
        # If arr2 element is present in
        # hash, store it in arr3
        if (arr2[i] in hash):
            arr3[k] = arr2[i]
            k += 1
             
            del hash[arr2[i]]
 
    # Store that elements of arr1 in arr3
    # that are present in hash
    for i in range(n):
 
        # If arr1 element is present
        # in hash, store it in arr3
        if (arr1[i] in hash):
            arr3[k] = arr1[i]
            k += 1
             
            del hash[arr1[i]]
 
    # Copying 1st n elements of
    # arr3 to arr1
    for i in range(n):
        arr1[i] = arr3[i]
 
# Function to print array elements
def printArray(arr, n):
     
    for i in arr:
        print(i, end = " ")
         
    print()
 
# Driver Code
if __name__ == '__main__':
     
    array1 = [ 7, 4, 8, 0, 1 ]
    array2 = [ 9, 7, 2, 3, 6 ]
    size = len(array1)
     
    maximizeArray(array1, array2, size)
    printArray(array1, size)
     
# This code is contributed by mohit kumar 29

                    

C#

// C# program to print the maximum elements
// giving second array higher priority
using System;
using System.Collections.Generic;
 
class GFG
{
 
// Function to maximize array elements
static void maximizeArray(int[] arr1, int[] arr2)
{
    // auxiliary array arr3 to store
    // elements of arr1 & arr2
    int []arr3 = new int[10];
    for(int i = 0; i < arr3.Length; i++)
    {
        //arr2 has high priority
        arr3[i] = 0;
    }
     
    // Arraylist to store n largest
    // unique elements
    List<int> al = new List<int>();
     
    for(int i = 0; i < arr2.Length; i++)
    {
        if(arr3[arr2[i]] == 0)
        {
            // to avoid repetition of digits of arr2 in arr3
            arr3[arr2[i]] = 2;
             
            // simultaneously setting arraylist to
            // preserve order of arr2 and arr3
            al.Add(arr2[i]);
        }
    }
     
    for(int i = 0; i < arr1.Length; i++)
    {
        if(arr3[arr1[i]] == 0)
        {
            // if digit is already present in arr2
            // then priority is arr2
            arr3[arr1[i]] = 1;
             
            // simultaneously setting arraylist to
            // preserve order of arr1
            al.Add(arr1[i]);
        }
    }
 
    // to get only highest n elements(arr2+arr1)
    // and remove others from arraylist
    int count = 0;
    for(int j = 9; j >= 0; j--)
    {
        if(count < arr1.Length &
        (arr3[j] == 2 || arr3[j] == 1))
        {
            // to not allow those elements
            // which are absent in both arrays
            count++;
        }
        else
        {
            al.Remove(j);
        }
    }
 
    int c = 0;
    foreach(int x in al)
    {
        arr1[c++] = x;
    }
}
 
// Function to print array elements
static void printArray(int[] arr)
{
    foreach(int x in arr)
    {
        Console.Write(x + " ");
    }
}
 
// Driver Code
public static void Main(String []args)
{
    int []arr1 = {7, 4, 8, 0, 1};
    int []arr2 = {9, 7, 2, 3, 6};
    maximizeArray(arr1, arr2);
    printArray(arr1);
}
}
 
// This code is contributed by PrinciRaj1992

                    

Javascript

<script>
// Javascript program to print the maximum elements
// giving second array higher priority
 
// Function to maximize array elements
function maximizeArray(arr1,arr2)
{
 
    // auxiliary array arr3 to store
    // elements of arr1 & arr2
    let arr3 = new Array(10);
    for(let i = 0; i < arr3.length; i++)
    {
        // arr2 has high priority
        arr3[i] = 0;
    }
       
    // Arraylist to store n largest
    // unique elements
    let al = [];
       
    for(let i = 0; i < arr2.length; i++)
    {
        if(arr3[arr2[i]] == 0)
        {
         
            // to avoid repetition of digits of arr2 in arr3
            arr3[arr2[i]] = 2;
               
            // simultaneously setting arraylist to
            // preserve order of arr2 and arr3
            al.push(arr2[i]);
        }
    }
     
    for(let i = 0; i < arr1.length; i++)
    {
        if(arr3[arr1[i]] == 0)
        {
         
            // if digit is already present in arr2
            // then priority is arr2
            arr3[arr1[i]] = 1;
               
            // simultaneously setting arraylist to
            // preserve order of arr1
            al.push(arr1[i]);
        }
    }
   
    // to get only highest n elements(arr2+arr1)
    // and remove others from arraylist
    let count = 0;
    for(let j = 9; j >= 0; j--)
    {
        if(count < arr1.length &
          (arr3[j] == 2 || arr3[j] == 1))
        {
         
            // to not allow those elements
            // which are absent in both arrays
            count++;
        }
        else
        {   
             
            if(al.indexOf(j)>0)
                al.splice(al.indexOf(j),1);
                 
        }
    }
   
    let i = 0;
    for(let x = 0; x < al.length; x++)
    {
        arr1[i++] = al[x];
    }
    
}
 
// Function to print array elements
function printArray(arr)
{
    for(let x=0; x<arr.length;x++)
    {
        document.write(arr[x] + " ");
    }
}
 
// Driver Code
let arr1=[7, 4, 8, 0, 1];
let arr2=[9, 7, 2, 3, 6];
maximizeArray(arr1,arr2);
printArray(arr1);
     
// This code is contributed by patel2127
</script>

                    

Output
9 7 6 4 8






Complexity Analysis:

  • Time complexity: O(n * log n).
  • Auxiliary Space: O(n).

ANOTHER APPROACH USING PRIORITY QUEUE:

Intuition:

  1. We create a  priority queue which implements max heap to keep max elements on top of queue.
  2. We create a set data structure to insert top n max elements in the set which are unique.
  3. Lastly we run a loop through arr2 and see if there exists that element in the set and we add it to the list 
  4. and similarly we do it for arr1.
  5. Lastly we return the list.

Implementation:

C++

#include <bits/stdc++.h>
using namespace std;
 
vector<int> maximizeArray(int arr1[], int arr2[], int n){
    vector<int> ans;
    unordered_set<int> set;
    priority_queue<int> pq;
 
    // Add all elements of arr1 and arr2 to the priority queue
    for (int i = 0; i < n; i++) {
        pq.push(arr1[i]);
        pq.push(arr2[i]);
    }
 
    // Select the n maximum elements from the priority queue
    while (set.size() != n) {
        int top = pq.top();
        pq.pop();
        set.insert(top);
    }
 
    // Add elements from arr2 that are in the set to the answer vector
    for (int i = 0; i < n; i++) {
        if (set.find(arr2[i]) != set.end()) {
            ans.push_back(arr2[i]);
            set.erase(arr2[i]);
        }
    }
 
    // Add elements from arr1 that are in the set to the answer vector
    for (int i = 0; i < n; i++) {
        if (set.find(arr1[i]) != set.end()) {
            ans.push_back(arr1[i]);
            set.erase(arr1[i]);
        }
    }
 
    return ans;
}
 
int main(){
    int arr1[] = { 7, 4, 8, 0, 1 };
    int arr2[] = { 9, 7, 2, 3, 6 };
    int n = sizeof(arr1) / sizeof(arr1[0]);
 
    vector<int> result = maximizeArray(arr1, arr2, n);
 
    for (int i = 0; i < n; i++)
        cout << result[i] << " ";
   
    cout << endl;
    return 0;
}
// THIS CODE IS CONTRIBUTED BY CHANDAN AGARWAL

                    

Java

// Java program to print the maximum elements
// giving second array higher priority
 
import java.io.*;
import java.util.*;
 
class GFG {
    static ArrayList<Integer>
    maximizeArray(int[] arr1, int[] arr2, int n)
    {
        // code here
        ArrayList<Integer> ans = new ArrayList<Integer>();
        HashSet<Integer> set = new HashSet<>();
        PriorityQueue<Integer> pq = new PriorityQueue<>(
            Collections.reverseOrder());
 
        for (int i : arr1)
            pq.offer(i);
 
        for (int i : arr2)
            pq.offer(i);
 
        while (set.size() != n)
            set.add(pq.poll());
 
        for (int i : arr2) {
            if (set.contains(i)) {
                ans.add(i);
                set.remove(i);
            }
        }
        for (int i : arr1) {
            if (set.contains(i)) {
                ans.add(i);
                set.remove(i);
            }
        }
        return ans;
    }
    public static void main(String[] args)
    {
        int arr1[] = { 7, 4, 8, 0, 1 };
        int arr2[] = { 9, 7, 2, 3, 6 };
        System.out.println(maximizeArray(arr1, arr2, 5));
    }
}
//This code is contributed by Raunak Singh

                    

Python3

import heapq
 
def maximize_array(arr1, arr2, n):
    ans = []
    unique_set = set()
    max_heap = []
 
    # Add all elements of arr1 and arr2 to the max heap
    for i in range(n):
        heapq.heappush(max_heap, -arr1[i])  # Using negative values for max heap behavior
        heapq.heappush(max_heap, -arr2[i])
 
    # Select the n maximum elements from the max heap
    while len(unique_set) != n:
        top = -heapq.heappop(max_heap)  # Negate again to get the actual value
        unique_set.add(top)
 
    # Add elements from arr2 that are in the set to the answer list
    for i in range(n):
        if arr2[i] in unique_set:
            ans.append(arr2[i])
            unique_set.remove(arr2[i])
 
    # Add elements from arr1 that are in the set to the answer list
    for i in range(n):
        if arr1[i] in unique_set:
            ans.append(arr1[i])
            unique_set.remove(arr1[i])
 
    return ans
 
def main():
    arr1 = [7, 4, 8, 0, 1]
    arr2 = [9, 7, 2, 3, 6]
    n = len(arr1)
 
    result = maximize_array(arr1, arr2, n)
 
    for num in result:
        print(num, end=" ")
 
    print()
 
if __name__ == "__main__":
    main()

                    

C#

using System;
using System.Collections.Generic;
 
class GFG
{
    // Function to maximize the array based on the given rules
    static List<int> MaximizeArray(int[] arr1, int[] arr2, int n)
    {
        List<int> ans = new List<int>();
        HashSet<int> set = new HashSet<int>();
        PriorityQueue<int> pq = new PriorityQueue<int>((x, y) => y.CompareTo(x));
 
        // Adding all elements of arr1 and arr2 to the priority queue
        foreach (int i in arr1)
            pq.Enqueue(i);
 
        foreach (int i in arr2)
            pq.Enqueue(i);
 
        // Select the n maximum elements from the priority queue
        while (set.Count != n)
            set.Add(pq.Dequeue());
 
        // Add elements from arr2 that are in the set to the answer list
        foreach (int i in arr2)
        {
            if (set.Contains(i))
            {
                ans.Add(i);
                set.Remove(i);
            }
        }
 
        // Add elements from arr1 that are in the set to the answer list
        foreach (int i in arr1)
        {
            if (set.Contains(i))
            {
                ans.Add(i);
                set.Remove(i);
            }
        }
        return ans;
    }
 
    public static void Main(string[] args)
    {
        int[] arr1 = { 7, 4, 8, 0, 1 };
        int[] arr2 = { 9, 7, 2, 3, 6 };
        List<int> result = MaximizeArray(arr1, arr2, 5);
 
        // Print the result
        foreach (int val in result)
            Console.Write(val + " ");
 
        Console.WriteLine();
    }
}
 
// Custom PriorityQueue class to implement priority queue in C#
public class PriorityQueue<T>
{
    private List<T> data;
    private readonly Comparison<T> comparison;
 
    // Constructor
    public PriorityQueue(Comparison<T> comparison)
    {
        data = new List<T>();
        this.comparison = comparison;
    }
 
    // Enqueue an item into the priority queue
    public void Enqueue(T item)
    {
        data.Add(item);
        int ci = data.Count - 1;
        while (ci > 0)
        {
            int pi = (ci - 1) / 2;
            if (comparison(data[ci], data[pi]) >= 0) break;
            T tmp = data[ci]; data[ci] = data[pi]; data[pi] = tmp;
            ci = pi;
        }
    }
 
    // Dequeue the highest priority item from the priority queue
    public T Dequeue()
    {
        if (Count == 0) throw new InvalidOperationException("PriorityQueue is empty");
        int li = data.Count - 1;
        T frontItem = data[0];
        data[0] = data[li];
        data.RemoveAt(li);
 
        --li;
        int pi = 0;
        while (true)
        {
            int ci = pi * 2 + 1;
            if (ci > li) break;
            int rc = ci + 1;
            if (rc <= li && comparison(data[rc], data[ci]) < 0) ci = rc;
            if (comparison(data[pi], data[ci]) <= 0) break;
            T tmp = data[pi]; data[pi] = data[ci]; data[ci] = tmp;
            pi = ci;
        }
        return frontItem;
    }
 
    // Peek the highest priority item from the priority queue
    public T Peek()
    {
        if (Count == 0) throw new InvalidOperationException("PriorityQueue is empty");
        return data[0];
    }
 
    // Get the number of items in the priority queue
    public int Count { get { return data.Count; } }
 
    // Override ToString() to display the priority queue as a string
    public override string ToString()
    {
        string s = "";
        for (int i = 0; i < data.Count; ++i)
            s += data[i].ToString() + " ";
        s += "count = " + data.Count;
        return s;
    }
 
    // Check if the priority queue is consistent
    public bool IsConsistent()
    {
        if (data.Count == 0) return true;
        int li = data.Count - 1;
        for (int pi = 0; pi < data.Count; ++pi)
        {
            int lci = 2 * pi + 1;
            int rci = 2 * pi + 2;
            if (lci <= li && comparison(data[pi], data[lci]) > 0) return false;
            if (rci <= li && comparison(data[pi], data[rci]) > 0) return false;
        }
        return true;
    }
}

                    

Javascript

function maximizeArray(arr1, arr2, n) {
  let ans = [];
  let set = new Set();
  let pq = [];
 
  // Add all elements of arr1 and arr2 to the priority queue
  for (let i = 0; i < n; i++) {
    pq.push(arr1[i]);
    pq.push(arr2[i]);
  }
 
  // Select the n maximum elements from the priority queue
  while (set.size != n) {
    let top = Math.max(...pq);
    pq.splice(pq.indexOf(top), 1);
    set.add(top);
  }
 
  // Add elements from arr2 that are in the set to the answer array
  for (let i = 0; i < n; i++) {
    if (set.has(arr2[i])) {
      ans.push(arr2[i]);
      set.delete(arr2[i]);
    }
  }
 
  // Add elements from arr1 that are in the set to the answer array
  for (let i = 0; i < n; i++) {
    if (set.has(arr1[i])) {
      ans.push(arr1[i]);
      set.delete(arr1[i]);
    }
  }
 
  return ans;
}
 
let arr1 = [7, 4, 8, 0, 1];
let arr2 = [9, 7, 2, 3, 6];
let n = arr1.length;
 
let result = maximizeArray(arr1, arr2, n);
 
for (let i = 0; i < n; i++) process.stdout.write(result[i] + " ");
// THIS CODE IS CONTRIBUTED BY CHANDAN AGARWAL

                    

Output
[9, 7, 6, 4, 8]







Time Complexity:  O(N*logN)

Space Complexity: O(N) since we using priority queue and set



Last Updated : 18 Sep, 2023
Like Article
Save Article
Share your thoughts in the comments
Similar Reads