Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Maximize cost to empty an array by removing contiguous subarrays of equal elements

  • Difficulty Level : Hard
  • Last Updated : 12 Jun, 2021

Given an array arr[] consisting of N integers and an integer M, the task is to find the maximum cost that can be obtained by performing the following operation any number of times. 

In one operation, choose K contiguous elements with same value(where K ≥ 1) and remove them and cost of this operation is K * M. 

Examples: 

Input: arr[] = {1, 3, 2, 2, 2, 3, 4, 3, 1}, M = 3 
Output: 27 
Explanation: 
Step 1: Remove three contiguous 2’s to modify arr[] = {1, 3, 3, 4, 3, 1}. Cost = 3 * 3 = 9 
Step 2: Remove 4 to modify arr[] = {1, 3, 3, 3, 1}. Cost = 9 + 1 * 3 = 12 
Step 3: Remove three contiguous 3’s to modify arr[] = {1, 1}. Cost = 12 + 3 * 3 = 21 
Step 4: Remove two contiguous 1’s to modify arr[] = {}. Cost = 21 + 2 * 3 = 27

Input: arr[] = {1, 2, 3, 4, 5, 6, 7}, M = 2 
Output: 14

Approach: This problem can be solved using Dynamic Programming. Below are the steps:

  1. Initialize a 3D array dp[][][] such that dp[left][right][count], where left and right denotes operation between indices [left, right] and count is the number of elements to the left of arr[left] having same value as that of arr[left] and the count excludes arr[left].
  2. Now there are the following two possible choices: 
    • Ending the sequence to remove the elements of the same value including the starting element (i.e., arr[left]) and then continue from the next element onward.
    • Continue the sequence to search between the indices [left + 1, right] for elements having the same value as arr[left](say index i), this enables us to continue the sequence.
  3. Make recursive calls from the new sequence and continue the process for the previous sequence.
  4. Print the maximum cost after all the above steps.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Initialize dp array
int dp[101][101][101];
 
// Function that removes elements
// from array to maximize the cost
int helper(int arr[], int left, int right,
           int count, int m)
{
    // Base case
    if (left > right)
        return 0;
 
    // Check if an answer is stored
    if (dp[left][right][count] != -1) {
        return dp[left][right][count];
    }
 
    // Deleting count + 1 i.e. including
    // the first element and starting a
    // new sequence
    int ans = (count + 1) * m
              + helper(arr, left + 1,
                       right, 0, m);
 
    for (int i = left + 1;
         i <= right; ++i) {
 
        if (arr[i] == arr[left]) {
 
            // Removing [left + 1, i - 1]
            // elements to continue with
            // previous sequence
            ans = max(
                ans,
                helper(arr, left + 1,
                       i - 1, 0, m)
                    + helper(arr, i, right,
                             count + 1, m));
        }
    }
 
    // Store the result
    dp[left][right][count] = ans;
 
    // Return answer
    return ans;
}
 
// Function to remove the elements
int maxPoints(int arr[], int n, int m)
{
    int len = n;
    memset(dp, -1, sizeof(dp));
 
    // Function Call
    return helper(arr, 0, len - 1, 0, m);
}
 
// Driver Code
int main()
{
    // Given array
    int arr[] = { 1, 3, 2, 2, 2, 3, 4, 3, 1 };
 
    int M = 3;
 
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    cout << maxPoints(arr, N, M);
    return 0;
}
Java



// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Initialize dp array
static int [][][]dp = new int[101][101][101];
 
// Function that removes elements
// from array to maximize the cost
static int helper(int arr[], int left, int right,
                  int count, int m)
{
     
    // Base case
    if (left > right)
        return 0;
 
    // Check if an answer is stored
    if (dp[left][right][count] != -1)
    {
        return dp[left][right][count];
    }
 
    // Deleting count + 1 i.e. including
    // the first element and starting a
    // new sequence
    int ans = (count + 1) * m +
             helper(arr, left + 1,
                    right, 0, m);
 
    for(int i = left + 1; i <= right; ++i)
    {
        if (arr[i] == arr[left])
        {
             
            // Removing [left + 1, i - 1]
            // elements to continue with
            // previous sequence
            ans = Math.max(ans,
                  helper(arr, left + 1,
                         i - 1, 0, m) +
                  helper(arr, i, right,
                         count + 1, m));
        }
    }
 
    // Store the result
    dp[left][right][count] = ans;
 
    // Return answer
    return ans;
}
 
// Function to remove the elements
static int maxPoints(int arr[], int n, int m)
{
    int len = n;
    for(int i = 0; i < 101; i++)
    {
        for(int j = 0; j < 101; j++)
        {
            for(int k = 0; k < 101; k++)
                dp[i][j][k] = -1;
        }
    }
 
    // Function call
    return helper(arr, 0, len - 1, 0, m);
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Given array
    int arr[] = { 1, 3, 2, 2, 2, 3, 4, 3, 1 };
 
    int M = 3;
 
    int N = arr.length;
 
    // Function call
    System.out.print(maxPoints(arr, N, M));
}
}
 
// This code is contributed by Amit Katiyar
Python3



# Python3 program for
# the above approach
 
# Initialize dp array
dp = [[[-1 for x in range(101)]
            for y in range(101)]
            for z in range(101)]
  
# Function that removes elements
# from array to maximize the cost
def helper(arr, left,
           right, count, m):
 
  # Base case
  if (left > right):
    return 0
 
  # Check if an answer is stored
  if (dp[left][right][count] != -1):
    return dp[left][right][count]
 
  # Deleting count + 1 i.e. including
  # the first element and starting a
  # new sequence
  ans = ((count + 1) * m +
          helper(arr, left + 1,
                 right, 0, m))
 
  for i in range (left + 1,
                  right + 1):
 
    if (arr[i] == arr[left]):
 
      # Removing [left + 1, i - 1]
      # elements to continue with
      # previous sequence
      ans = (max(ans, helper(arr, left + 1,
                             i - 1, 0, m) +
                         helper(arr, i, right,
                              count + 1, m)))
 
      # Store the result
      dp[left][right][count] = ans
 
      # Return answer
      return ans
  
# Function to remove the elements
def maxPoints(arr, n, m):
  length = n
  global dp
 
  # Function Call
  return helper(arr, 0,
                length - 1, 0, m)
  
# Driver Code
if __name__ == "__main__":
 
  # Given array
  arr = [1, 3, 2, 2,
         2, 3, 4, 3, 1]
  M = 3
  N = len(arr)
 
  # Function Call
  print(maxPoints(arr, N, M))
     
# This code is contributed by Chitranayal
C#



// C# program for the above approach
using System;
 
class GFG{
 
// Initialize dp array
static int [,,]dp = new int[101, 101, 101];
 
// Function that removes elements
// from array to maximize the cost
static int helper(int []arr, int left, int right,
                  int count, int m)
{
     
    // Base case
    if (left > right)
        return 0;
 
    // Check if an answer is stored
    if (dp[left, right, count] != -1)
    {
        return dp[left, right, count];
    }
 
    // Deleting count + 1 i.e. including
    // the first element and starting a
    // new sequence
    int ans = (count + 1) * m +
              helper(arr, left + 1,
                    right, 0, m);
 
    for(int i = left + 1; i <= right; ++i)
    {
        if (arr[i] == arr[left])
        {
             
            // Removing [left + 1, i - 1]
            // elements to continue with
            // previous sequence
            ans = Math.Max(ans,
                  helper(arr, left + 1,
                         i - 1, 0, m) +
                  helper(arr, i, right,
                         count + 1, m));
        }
    }
 
    // Store the result
    dp[left, right, count] = ans;
 
    // Return answer
    return ans;
}
 
// Function to remove the elements
static int maxPoints(int []arr, int n, int m)
{
    int len = n;
    for(int i = 0; i < 101; i++)
    {
        for(int j = 0; j < 101; j++)
        {
            for(int k = 0; k < 101; k++)
                dp[i, j, k] = -1;
        }
    }
 
    // Function call
    return helper(arr, 0, len - 1, 0, m);
}
 
// Driver Code
public static void Main(String[] args)
{
     
    // Given array
    int []arr = { 1, 3, 2, 2, 2, 3, 4, 3, 1 };
 
    int M = 3;
 
    int N = arr.Length;
 
    // Function call
    Console.Write(maxPoints(arr, N, M));
}
}
 
// This code is contributed by Amit Katiyar
Javascript



<script>
 
// Javascript program for the above approach
 
// Initialize dp array
let dp = new Array(101);
for(let i = 0; i < 101; i++)
{
    dp[i] = new Array(101);
    for(let j = 0; j < 101; j++)
    {
        dp[i][j] = new Array(101);
        for(let k = 0; k < 101; k++)
        {
            dp[i][j][k] = -1;
        }
    }
}
 
// Function that removes elements
// from array to maximize the cost
function helper(arr, left, right, count, m)
{
     
    // Base case
    if (left > right)
        return 0;
 
    // Check if an answer is stored
    if (dp[left][right][count] != -1)
    {
        return dp[left][right][count];
    }
 
    // Deleting count + 1 i.e. including
    // the first element and starting a
    // new sequence
    let ans = (count + 1) * m +
              helper(arr, left + 1,
                     right, 0, m);
 
    for(let i = left + 1; i <= right; ++i)
    {
        if (arr[i] == arr[left])
        {
             
            // Removing [left + 1, i - 1]
            // elements to continue with
            // previous sequence
            ans = Math.max(ans,
                  helper(arr, left + 1,
                         i - 1, 0, m) +
                  helper(arr, i, right,
                         count + 1, m));
        }
    }
 
    // Store the result
    dp[left][right][count] = ans;
 
    // Return answer
    return ans;
}
 
// Function to remove the elements
function maxPoints(arr, n, m)
{
    let len = arr.length;
     
    // Function call
    return helper(arr, 0, len - 1, 0, m);
}
 
// Driver Code
 
// Given array
let arr = [ 1, 3, 2, 2, 2, 3, 4, 3, 1 ];
let M = 3;
let N = arr.length;
 
// Function call
document.write(maxPoints(arr, N, M));
 
// This code is contributed by avanitrachhadiya2155
 
</script>
Output: 
27
Time Complexity: O(N4) 
Auxiliary Space: O(N3) 

My Personal Notes
arrow_drop_up
Previous
Count array elements that can be maximized by adding any permutation of first N natural numbers
Next

Mode of frequencies of given array elements
Recommended Articles
Page :
Maximize cost to empty given array by repetitively removing K array elements
23, Nov 20
Minimum cost to empty Array where cost of removing an element is 2^(removed_count) * arr[i]
20, Jul 20
Minimize cost to empty given array where cost of removing an element is its absolute difference with Time instant
08, Dec 20
Split an Array to maximize subarrays having equal count of odd and even elements for a cost not exceeding K
02, Sep 20
Minimize cost to empty a given string by removing characters alphabetically
30, Aug 20
Minimize operations of removing 2i -1 array elements to empty given array
17, Jan 21
Partitioning into two contiguous element subarrays with equal sums
30, May 18
Count ways to split array into three non-empty subarrays having equal Bitwise XOR values
09, Jun 21
Maximize cost of segment having weight at most K from given weight and cost of N items
09, Dec 21
Count of ways to split an Array into three contiguous Subarrays having increasing Sum
15, Aug 20
Queries to find maximum sum contiguous subarrays of given length in a rotating array
15, Sep 20
Maximum product of sum of two contiguous subarrays of an array
20, Jan 20
Maximum contiguous decreasing sequence obtained by removing any one element
18, Mar 20
Split given arrays into subarrays to maximize the sum of maximum and minimum in each subarrays
27, Sep 21
Maximize sum of product of same-indexed elements of equal length subarrays obtained from two given arrays
30, Apr 21
Steps to make array empty by removing maximum and its right side
06, Oct 17
Empty an Array by removing maximum of K value from it
30, Jan 20
Min steps to empty an Array by removing a pair each time with sum at most K
08, Jul 20
Minimize cost to sort the Array by moving elements with cost as the value itself
29, Sep 21
Minimum cost to convert all elements of a K-size subarray to 0 from given Ternary Array with subarray sum as cost
05, Jul 21
Maximize the sum of differences of consecutive elements after removing exactly K elements
02, Jan 20
Longest subarray of non-empty cells after removal of at most a single empty cell
08, Jul 20
Count of contiguous subarrays possible for every index by including the element at that index
08, May 20
Difference between maximum and minimum average of all K-length contiguous subarrays
12, Jul 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
rishabhtyagi2306
@rishabhtyagi2306
Vote for difficulty
Current difficulty :
Hard





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!