Maximize first element of Array by deleting first or adding a previously deleted element

• Last Updated : 08 Apr, 2022

Given an array arr[] of size N, and an integer K, the task is to maximize the first element of the array in K operations where in each operation:

• If the array is not empty, remove the topmost element of the array.
• Add any one of the previously removed element back at the starting of the array.

Examples:

Input: arr[] = [5, 2, 2, 4, 0, 6], K = 4
Output: 5
Explanation: The 4 operations are as:

• Remove the topmost element = 5. The arr becomes [2, 2, 4, 0, 6].
• Remove the topmost element = 2. The arr becomes [2, 4, 0, 6].
• Remove the topmost element = 2. The arr becomes [4, 0, 6].
• Add 5 back onto the arr. The arr becomes [5, 4, 0, 6].

Here 5 is the largest answer possible after 4 moves.

Input: arr[] = [2], K = 1
Output: -1
Explanation: Only one move can be applied and in the first move.
The only option is to remove the first element of the arr[].
If that is done the array becomes empty. So answer is -1

Approach: This problem can be solved with the help of the Greedy approach based on the following idea:

In first K-1 operations, the K-1 value of the starting can be removed. So currently at Kth node. Now in the last operation there are two possible choice:

• Either remove the current starting node (optimal if the value of the (K+1)th node is greater than the largest amongst first K-1 already removed elements)
• Add the largest from the already removed K-1 elements (optimal when the (K+1)th node has less value than this largest one)

Follow the illustration shown below for a better understanding.

Illustration:

For example arr[] = {5, 2, 2, 4, 0, 6}, K = 4

1st Operation:
=> Remove 5. arr[] = {2, 2, 4, 0, 6}
=> maximum = 5, K = 4 – 1 = 3

2nd Operation:
=> Remove 2. arr[] = {2, 4, 0, 6}
=> maximum = max (5, 2) = 5, K = 3 – 1 = 2

3rd Operation:
=> Remove 2. arr[] = {4, 0, 6}
=> maximum = max (5, 2) = 5, K = 2 – 1 = 1

4th Operation:
=> Here the current 2nd element i.e. 0 is less than 5.
=> So add 5 back in the array. arr[] = {5, 4, 0, 6}
=> maximum = max (5, 0) = 5, K = 1 – 1 = 0

Therefore the maximum possible first element is 5.

Follow the steps to solve the problem:

• If K = 0, then return first node value.
• If K = 1, then return the second node value(if any) else return -1 (because after K operations the list does not exist).
• If the size of the linked list is one then in every odd operation (i.e. 1, 3, 5, . . . ), return -1, else return the first node value (because if performed odd operation then array will become empty).
• If K > 2, then:
• Traverse first K-1 nodes and find out the maximum value.
• Compare that maximum value with the (K+1)th node value.
• If (K+1)th value is greater than the previous maximum value, update it with (K+1)th Node value. Otherwise, don’t update the maximum value.
• Return the maximum value.

Below is the implementation of the above approach :

C++

 `// C++ code to implement the approach` `#include ` `using` `namespace` `std;`   `int` `maximumTopMost(``int` `arr[], ``int` `k,``int` `N){`   `   ``// Checking if k is odd and ` `    ``// length of array is 1` `    ``if` `(N == 1 and k % 2 != 0)` `        ``return` `-1;`   `    ``// Initializing ans with -1` `    ``int` `ans = -1;`   `    ``// If k is greater or equal to the` `    ``// length of array` `    ``for``(``int` `i  = 0; i <  min(N, k - 1); i++)` `        ``ans = max(ans, arr[i]);`   `    ``// If k is less than length of array` `    ``if` `(k < N)` `        ``ans = max(ans, arr[k]);`   `    ``// Returning ans` `    ``return` `ans;` `}`   `// Driver code` `int` `main() {`   `      ``int` `arr[] = {5, 2, 2, 4, 0, 6};` `      ``int` `N = 6;` `      ``int` `K = 4;` `      ``cout <<(maximumTopMost(arr, K, N));` `      ``return` `0;` `}`   `// This code is contributed by hrithikgarg03188.`

Java

 `// Java code to implement the approach` `class` `GFG {`   `  ``static` `int` `maximumTopMost(``int``[] arr, ``int` `k, ``int` `N)` `  ``{`   `    ``// Checking if k is odd and` `    ``// length of array is 1` `    ``if` `(N == ``1` `&& k % ``2` `!= ``0``)` `      ``return` `-``1``;`   `    ``// Initializing ans with -1` `    ``int` `ans = -``1``;`   `    ``// If k is greater or equal to the` `    ``// length of array` `    ``for` `(``int` `i = ``0``; i < Math.min(N, k - ``1``); i++)` `      ``ans = Math.max(ans, arr[i]);`   `    ``// If k is less than length of array` `    ``if` `(k < N)` `      ``ans = Math.max(ans, arr[k]);`   `    ``// Returning ans` `    ``return` `ans;` `  ``}` `  ``public` `static` `void` `main(String[] args)` `  ``{`   `    ``int``[] arr = { ``5``, ``2``, ``2``, ``4``, ``0``, ``6` `};` `    ``int` `N = ``6``;` `    ``int` `K = ``4``;` `    ``System.out.println(maximumTopMost(arr, K, N));` `  ``}` `}`   `// This code is contributed by phasing17.`

Python3

 `# Python code to implement the approach`   `def` `maximumTopMost(arr, k):`   `    ``# Checking if k is odd and ` `    ``# length of array is 1` `    ``if` `len``(arr) ``=``=` `1` `and` `k ``%` `2` `!``=` `0``:` `        ``return` `-``1`   `    ``# Initializing ans with -1` `    ``ans ``=` `-``1`   `    ``# If k is greater or equal to the` `    ``# length of array` `    ``for` `i ``in` `range``(``min``(``len``(arr), k ``-` `1``)):` `        ``ans ``=` `max``(ans, arr[i])`   `    ``# If k is less than length of array` `    ``if` `k < ``len``(arr):` `        ``ans ``=` `max``(ans, arr[k])`   `    ``# Returning ans` `    ``return` `ans`     `# Driver code` `if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``5``, ``2``, ``2``, ``4``, ``0``, ``6``]` `    ``K ``=` `4` `    ``print``(maximumTopMost(arr, K))`

C#

 `// C# code to implement the approach` `using` `System;` `class` `GFG {`   `  ``static` `int` `maximumTopMost(``int``[] arr, ``int` `k, ``int` `N)` `  ``{`   `    ``// Checking if k is odd and` `    ``// length of array is 1` `    ``if` `(N == 1 && k % 2 != 0)` `      ``return` `-1;`   `    ``// Initializing ans with -1` `    ``int` `ans = -1;`   `    ``// If k is greater or equal to the` `    ``// length of array` `    ``for` `(``int` `i = 0; i < Math.Min(N, k - 1); i++)` `      ``ans = Math.Max(ans, arr[i]);`   `    ``// If k is less than length of array` `    ``if` `(k < N)` `      ``ans = Math.Max(ans, arr[k]);`   `    ``// Returning ans` `    ``return` `ans;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `Main()` `  ``{`   `    ``int``[] arr = { 5, 2, 2, 4, 0, 6 };` `    ``int` `N = 6;` `    ``int` `K = 4;` `    ``Console.Write(maximumTopMost(arr, K, N));` `  ``}` `}`   `// This code is contributed by Samim Hossain Mondal.`

Javascript

 ``

Output

`5`

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles