Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Minimum removals required to make a given array Bitonic

  • Difficulty Level : Expert
  • Last Updated : 09 Jun, 2021

Given an array arr[] of size N, the task is to find the minimum number of array elements required to be removed from the array such that the given array is converted to a bitonic array.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = { 2, 1, 1, 5, 6, 2, 3, 1 } 
Output: 3 
Explanation: 
Removing arr[0], arr[1] and arr[5] modifies arr[] to { 1, 5, 6, 3, 1 } 
Since the array elements follow an increasing order followed by a decreasing order, the required output is 3.



Input: arr[] = { 1, 3, 1 } 
Output: 0 
Explanation: 
The given array is already a bitonic array. Therefore, the required output is 3.

Approach: The problem can be solved based on the concept of the longest increasing subsequence problem. Follow the steps below to solve the problem:

  • Initialize a variable, say left[], such that left[i] stores the length of the longest increasing subsequence up to the ith index.
  • Initialize a variable, say right[], such that right[i] stores the length of the longest decreasing subsequence over the range [i, N].
  • Traverse left[] and right[] array using variable i and find the maximum value of (left[i] + right[i] – 1) and store it in a variable, say maxLen.
  • Finally, print the value of N – maxLen.

Below is the implementation of the above approach:

C++14




// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to coutnt minimum array elements
// required to be removed to make an array bitonic
void min_element_removal(int arr[], int N)
{
    // left[i]: Stores the length
    // of LIS up to i-th index
    vector<int> left(N, 1);
 
    // right[i]: Stores the length
    // of decreasing subsequence
    // over the range [i, N]
    vector<int> right(N, 1);
 
    // Calculate the length of LIS
    // up to i-th index
    for (int i = 1; i < N; i++) {
 
        // Traverse the array
        // upto i-th index
        for (int j = 0; j < i; j++) {
 
            // If arr[j] is less than arr[i]
            if (arr[j] < arr[i]) {
 
                // Update left[i]
                left[i] = max(left[i],
                              left[j] + 1);
            }
        }
    }
 
    // Calculate the length of decreasing
    // subsequence over the range [i, N]
    for (int i = N - 2; i >= 0;
         i--) {
 
        // Traverse right[] array
        for (int j = N - 1; j > i;
             j--) {
 
            // If arr[i] is greater
            // than arr[j]
            if (arr[i] > arr[j]) {
 
                // Update right[i]
                right[i] = max(right[i],
                               right[j] + 1);
            }
        }
    }
 
    // Stores length of the
    // longest bitonic array
    int maxLen = 0;
 
    // Traverse left[] and right[] array
    for (int i = 1; i < N - 1; i++) {
 
        // Update maxLen
        maxLen = max(maxLen, left[i] + right[i] - 1);
    }
 
    cout << (N - maxLen) << "\n";
}
 
// Function to print minimum removals
// required to make given array bitonic
void makeBitonic(int arr[], int N)
{
    if (N == 1) {
        cout << "0" << endl;
        return;
    }
 
    if (N == 2) {
        if (arr[0] != arr[1])
            cout << "0" << endl;
        else
            cout << "1" << endl;
 
        return;
    }
 
    min_element_removal(arr, N);
}
 
// Driver Code
int main()
{
    int arr[] = { 2, 1, 1, 5, 6, 2, 3, 1 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    makeBitonic(arr, N);
 
    return 0;
}
Java



// Java program to implement
// the above approach
class GFG {
     
    // Function to coutnt minimum array elements
    // required to be removed to make an array bitonic
    static void min_element_removal(int arr[], int N)
    {
        // left[i]: Stores the length
        // of LIS up to i-th index
        int left[] = new int[N];
         
        for(int i = 0; i < N; i++)
            left[i] = 1;
     
        // right[i]: Stores the length
        // of decreasing subsequence
        // over the range [i, N]
        int right[] = new int[N];
         
        for(int i = 0; i < N; i++)
            right[i] = 1;
             
        // Calculate the length of LIS
        // up to i-th index
        for (int i = 1; i < N; i++) {
     
            // Traverse the array
            // upto i-th index
            for (int j = 0; j < i; j++) {
     
                // If arr[j] is less than arr[i]
                if (arr[j] < arr[i]) {
     
                    // Update left[i]
                    left[i] = Math.max(left[i],
                                  left[j] + 1);
                }
            }
        }
     
        // Calculate the length of decreasing
        // subsequence over the range [i, N]
        for (int i = N - 2; i >= 0;
             i--) {
     
            // Traverse right[] array
            for (int j = N - 1; j > i;
                 j--) {
     
                // If arr[i] is greater
                // than arr[j]
                if (arr[i] > arr[j]) {
     
                    // Update right[i]
                    right[i] = Math.max(right[i],
                                   right[j] + 1);
                }
            }
        }
     
        // Stores length of the
        // longest bitonic array
        int maxLen = 0;
     
        // Traverse left[] and right[] array
        for (int i = 1; i < N - 1; i++) {
     
            // Update maxLen
            maxLen = Math.max(maxLen, left[i] + right[i] - 1);
        }
     
        System.out.println(N - maxLen);
    }
     
    // Function to print minimum removals
    // required to make given array bitonic
    static void makeBitonic(int arr[], int N)
    {
        if (N == 1) {
            System.out.println("0");
            return;
        }
     
        if (N == 2) {
            if (arr[0] != arr[1])
                System.out.println("0");
            else
                System.out.println("1");
     
            return;
        }
     
        min_element_removal(arr, N);
    }
     
    // Driver Code
    public static void main (String[] args) {
         
        int arr[] = { 2, 1, 1, 5, 6, 2, 3, 1 };
         
        int N = arr.length;
     
        makeBitonic(arr, N);
    }
}
 
// This code is contributed by AnkitRai01
Python3



# Python3 program to implement
# the above approach
 
# Function to coutnt minimum array elements
# required to be removed to make an array bitonic
def min_element_removal(arr, N):
     
    # left[i]: Stores the length
    # of LIS up to i-th index
    left = [1] * N
 
    # right[i]: Stores the length
    # of decreasing subsequence
    # over the range [i, N]
    right = [1] * (N)
 
    #Calculate the length of LIS
    #up to i-th index
    for i in range(1, N):
 
        #Traverse the array
        #upto i-th index
        for j in range(i):
 
            #If arr[j] is less than arr[i]
            if (arr[j] < arr[i]):
 
                #Update left[i]
                left[i] = max(left[i], left[j] + 1)
 
    # Calculate the length of decreasing
    # subsequence over the range [i, N]
    for i in range(N - 2, -1, -1):
 
        # Traverse right[] array
        for j in range(N - 1, i, -1):
 
            # If arr[i] is greater
            # than arr[j]
            if (arr[i] > arr[j]):
 
                # Update right[i]
                right[i] = max(right[i], right[j] + 1)
 
    # Stores length of the
    # longest bitonic array
    maxLen = 0
 
    # Traverse left[] and right[] array
    for i in range(1, N - 1):
 
        # Update maxLen
        maxLen = max(maxLen, left[i] + right[i] - 1)
 
    print((N - maxLen))
 
# Function to prminimum removals
# required to make given array bitonic
def makeBitonic(arr, N):
    if (N == 1):
        print("0")
        return
 
    if (N == 2):
        if (arr[0] != arr[1]):
            print("0")
        else:
            print("1")
 
        return
 
    min_element_removal(arr, N)
 
# Driver Code
if __name__ == '__main__':
    arr=[2, 1, 1, 5, 6, 2, 3, 1]
    N = len(arr)
 
    makeBitonic(arr, N)
 
    # This code is contributed by mohit kumar 29
C#



// C# program to implement
// the above approach
using System;
 
class GFG{
     
// Function to coutnt minimum array elements
// required to be removed to make an array bitonic
static void min_element_removal(int []arr, int N)
{
     
    // left[i]: Stores the length
    // of LIS up to i-th index
    int []left = new int[N];
     
    for(int i = 0; i < N; i++)
        left[i] = 1;
 
    // right[i]: Stores the length
    // of decreasing subsequence
    // over the range [i, N]
    int []right = new int[N];
     
    for(int i = 0; i < N; i++)
        right[i] = 1;
         
    // Calculate the length of LIS
    // up to i-th index
    for(int i = 1; i < N; i++)
    {
         
        // Traverse the array
        // upto i-th index
        for(int j = 0; j < i; j++)
        {
             
            // If arr[j] is less than arr[i]
            if (arr[j] < arr[i])
            {
                 
                // Update left[i]
                left[i] = Math.Max(left[i],
                                   left[j] + 1);
            }
        }
    }
 
    // Calculate the length of decreasing
    // subsequence over the range [i, N]
    for(int i = N - 2; i >= 0; i--)
    {
         
        // Traverse right[] array
        for(int j = N - 1; j > i; j--)
        {
             
            // If arr[i] is greater
            // than arr[j]
            if (arr[i] > arr[j])
            {
                 
                // Update right[i]
                right[i] = Math.Max(right[i],
                                    right[j] + 1);
            }
        }
    }
 
    // Stores length of the
    // longest bitonic array
    int maxLen = 0;
 
    // Traverse left[] and right[] array
    for(int i = 1; i < N - 1; i++)
    {
         
        // Update maxLen
        maxLen = Math.Max(maxLen, left[i] +
                                 right[i] - 1);
    }
    Console.WriteLine(N - maxLen);
}
 
// Function to print minimum removals
// required to make given array bitonic
static void makeBitonic(int []arr, int N)
{
    if (N == 1)
    {
        Console.WriteLine("0");
        return;
    }
 
    if (N == 2)
    {
        if (arr[0] != arr[1])
            Console.WriteLine("0");
        else
            Console.WriteLine("1");
             
        return;
    }
    min_element_removal(arr, N);
}
 
// Driver Code
public static void Main(String[] args)
{
    int []arr = { 2, 1, 1, 5, 6, 2, 3, 1 };
    int N = arr.Length;
 
    makeBitonic(arr, N);
}
}
 
// This code is contributed by AnkThon
Javascript



<script>
 
// Javascript program to implement
// the above approach
 
// Function to coutnt minimum array elements
// required to be removed to make an array bitonic
function min_element_removal(arr, N)
{
    // left[i]: Stores the length
    // of LIS up to i-th index
    var left = Array(N).fill(1);
 
    // right[i]: Stores the length
    // of decreasing subsequence
    // over the range [i, N]
    var right = Array(N).fill(1);
 
    // Calculate the length of LIS
    // up to i-th index
    for (var i = 1; i < N; i++) {
 
        // Traverse the array
        // upto i-th index
        for (var j = 0; j < i; j++) {
 
            // If arr[j] is less than arr[i]
            if (arr[j] < arr[i]) {
 
                // Update left[i]
                left[i] = Math.max(left[i],
                              left[j] + 1);
            }
        }
    }
 
    // Calculate the length of decreasing
    // subsequence over the range [i, N]
    for (var i = N - 2; i >= 0;
         i--) {
 
        // Traverse right[] array
        for (var j = N - 1; j > i;
             j--) {
 
            // If arr[i] is greater
            // than arr[j]
            if (arr[i] > arr[j]) {
 
                // Update right[i]
                right[i] = Math.max(right[i],
                               right[j] + 1);
            }
        }
    }
 
    // Stores length of the
    // longest bitonic array
    var maxLen = 0;
 
    // Traverse left[] and right[] array
    for (var i = 1; i < N - 1; i++) {
 
        // Update maxLen
        maxLen = Math.max(maxLen, left[i] + right[i] - 1);
    }
 
    document.write((N - maxLen) + "<br>");
}
 
// Function to print minimum removals
// required to make given array bitonic
function makeBitonic(arr, N)
{
    if (N == 1) {
        document.write( "0" + "<br>");
        return;
    }
 
    if (N == 2) {
        if (arr[0] != arr[1])
            document.write( "0" + "<br>");
        else
            document.write( "1" + "<br>");
 
        return;
    }
 
    min_element_removal(arr, N);
}
 
// Driver Code
var arr = [2, 1, 1, 5, 6, 2, 3, 1];
var N = arr.length;
makeBitonic(arr, N);
 
// This code is contributed by rutvik_56.
</script>
Output: 
3
 
Time Complexity: O(N2) 
Auxiliary Space: O(N)



My Personal Notes
arrow_drop_up
Previous
Queries to check if any pair exists in an array having values at most equal to the given pair
Next

Minimum time required to reach a given score
Recommended Articles
Page :
Minimum removals required to make any interval equal to the union of the given Set
05, Jan 21
Minimum removals required to make frequency of each array element equal to its value
08, Dec 20
Minimum removals required to make frequency of all remaining array elements equal
23, Feb 21
Find bitonic point in given bitonic sequence
18, Dec 16
Minimum substring removals required to make all remaining characters of a string same
03, Jan 21
Minimum removals required to convert given array to a Mountain Array
10, Dec 20
Minimize cost of removals required to make all remaining characters of the string unique
13, Jan 21
Minimum removals required such that given string consists only of a pair of alternating characters
16, Mar 21
Minimum removals required such that sum of remaining array modulo M is X
03, Nov 20
Minimum removals from array to make max - min <= K
02, Mar 18
Minimum removals to make array sum even
20, Mar 18
Minimum removals from array to make GCD greater
07, Oct 18
Minimum removals to make array sum odd
14, Feb 19
Minimum palindromic subarray removals to make array Empty
17, Jun 20
Minimum removals required to place all 0s before 1s in a Binary String
02, Mar 21
Minimum number of removals required such that no subsequence of length 2 occurs more than once
18, Jun 21
Minimum removals to make a string concatenation of a substring of 0s followed by a substring of 1s
14, Dec 20
Count possible removals to make absolute difference between the sum of odd and even indexed elements equal to K
10, Dec 20
Minimize difference between maximum and minimum array elements by exactly K removals
02, Dec 20
Minimum cost required to rearrange a given array to make it equal to another given array
25, Oct 20
Minimize consecutive removals of elements of the same type to empty given array
07, Dec 20
Maximum inversions possible after exactly K removals from given array
17, Nov 20
Maximum removals possible from an array such that sum of its elements is greater than or equal to that of another array
19, Jan 21
Minimum removals in a number to be divisible by 10 power raised to K
15, Dec 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
saikumarkudikala
@saikumarkudikala
Vote for difficulty
Current difficulty :
Expert





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!