Maximize elements using another array

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 ``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 al = ``new` `ArrayList();``    ` `    ``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

 ``

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 ``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``    ``maximizeArray(``int``[] arr1, ``int``[] arr2, ``int` `n)``    ``{``        ``// code here``        ``ArrayList ans = ``new` `ArrayList();``        ``HashSet set = ``new` `HashSet<>();``        ``PriorityQueue 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``{``    ``private` `List data;``    ``private` `readonly` `Comparison comparison;` `    ``// Constructor``    ``public` `PriorityQueue(Comparison comparison)``    ``{``        ``data = ``new` `List();``        ``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