Find maximum points which can be obtained by deleting elements from array - GeeksforGeeks

11 May, 2021
Given an array A having N elements and two integers L and R where, and . You can choose any element of the array (let’s say ax) and delete it, and also delete all elements equal to ax+1, ax+2 ... ax+R and ax-1, ax-2 ... ax-L from the array. This step will cost ax points. The task is to maximize the total cost after deleting all the elements from the array.Examples:  
Input : 2 1 2 3 2 2 1
        L = 1, R = 1
Output : 8
We select 2 to delete, then (2-1)=1 and (2+1)=3 will need to be deleted, 
for given L and R range respectively.
Repeat this until 2 is completely removed. So, total cost = 2*4 = 8.

Input : 2 4 2 9 5
        L = 1, R = 2
Output : 18
We select 2 to delete, then 5 and then 9.
So total cost = 2*2 + 5 + 9 = 18.
 
Approach: We will find the count of all the elements. Now let’s say an element X is selected then, all elements in the range [X-L, X+R] will be deleted. Now we select the minimum range from L and R and finds up to which elements are to be deleted when element X is selected. Our results will be the maximum of previously deleted elements and when element X is deleted. We will use dynamic programming to store the result of previously deleted elements and use it further.  
C++
Java
Python 3
C#
Javascript
// C++ program to find maximum cost after// deleting all the elements form the array#include <bits/stdc++.h>using namespace std; // function to return maximum cost obtainedint maxCost(int a[], int n, int l, int r){     int mx = 0, k;    // find maximum element of the array.    for (int i = 0; i < n; ++i)        mx = max(mx, a[i]);     // initialize count of all elements to zero.    int count[mx + 1];    memset(count, 0, sizeof(count));     // calculate frequency of all elements of array.    for (int i = 0; i < n; i++)        count[a[i]]++;     // stores cost of deleted elements.    int res[mx + 1];    res[0] = 0;     // selecting minimum range from L and R.    l = min(l, r);     for (int num = 1; num <= mx; num++) {         // finds upto which elements are to be        // deleted when element num is selected.        k = max(num - l - 1, 0);         // get maximum when selecting element num or not.        res[num] = max(res[num - 1], num * count[num] + res[k]);    }     return res[mx];} // Driver programint main(){    int a[] = { 2, 1, 2, 3, 2, 2, 1 }, l = 1, r = 1;     // size of array    int n = sizeof(a) / sizeof(a[0]);     // function call to find maximum cost    cout << maxCost(a, n, l, r);     return 0;}
//Java program to find maximum cost after//deleting all the elements form the array public class GFG {         //function to return maximum cost obtained    static int maxCost(int a[], int n, int l, int r)    {      int mx = 0, k;     // find maximum element of the array.     for (int i = 0; i < n; ++i)         mx = Math.max(mx, a[i]);      // initialize count of all elements to zero.     int[] count = new int[mx + 1];     for(int i = 0; i < count.length; i++)         count[i] = 0;      // calculate frequency of all elements of array.     for (int i = 0; i < n; i++)         count[a[i]]++;      // stores cost of deleted elements.     int[] res = new int[mx + 1];     res[0] = 0;      // selecting minimum range from L and R.     l = Math.min(l, r);      for (int num = 1; num <= mx; num++) {          // finds upto which elements are to be         // deleted when element num is selected.         k = Math.max(num - l - 1, 0);          // get maximum when selecting element num or not.         res[num] = Math.max(res[num - 1], num * count[num] + res[k]);     }      return res[mx];    }     //Driver program    public static void main(String[] args) {                 int a[] = { 2, 1, 2, 3, 2, 2, 1 }, l = 1, r = 1;          // size of array         int n = a.length;          // function call to find maximum cost         System.out.println(maxCost(a, n, l, r));    }}
# Python 3 Program to find maximum cost after# deleting all the elements form the array # function to return maximum cost obtaineddef maxCost(a, n, l, r) :     mx = 0     # find maximum element of the array.    for i in range(n) :        mx = max(mx, a[i])     # create and initialize count of all elements to zero.    count = [0] * (mx + 1)     # calculate frequency of all elements of array.    for i in range(n) :        count[a[i]] += 1     # stores cost of deleted elements.    res = [0] * (mx + 1)    res[0] = 0     # selecting minimum range from L and R.    l = min(l, r)     for num in range(1, mx + 1) :         # finds upto which elements are to be        # deleted when element num is selected.        k = max(num - l - 1, 0)         # get maximum when selecting element num or not.        res[num] = max(res[num - 1], num * count[num] + res[k])     return res[mx] # Driver codeif __name__ == "__main__" :     a = [2, 1, 2, 3, 2, 2, 1 ]    l, r = 1, 1     # size of array    n =  len(a)     # function call to find maximum cost    print(maxCost(a, n, l, r)) # This code is contributed by ANKITRAI1
// C# program to find maximum cost// after deleting all the elements// form the arrayusing System; class GFG{ // function to return maximum// cost obtainedstatic int maxCost(int []a, int n,                   int l, int r){    int mx = 0, k;         // find maximum element    // of the array.    for (int i = 0; i < n; ++i)        mx = Math.Max(mx, a[i]);         // initialize count of all    // elements to zero.    int[] count = new int[mx + 1];    for(int i = 0; i < count.Length; i++)        count[i] = 0;         // calculate frequency of all    // elements of array.    for (int i = 0; i < n; i++)        count[a[i]]++;         // stores cost of deleted elements.    int[] res = new int[mx + 1];    res[0] = 0;         // selecting minimum range    // from L and R.    l = Math.Min(l, r);         for (int num = 1; num <= mx; num++)    {             // finds upto which elements        // are to be deleted when        // element num is selected.        k = Math.Max(num - l - 1, 0);             // get maximum when selecting        // element num or not.        res[num] = Math.Max(res[num - 1], num *                          count[num] + res[k]);    } return res[mx];} // Driver Codepublic static void Main(){    int []a = { 2, 1, 2, 3, 2, 2, 1 };    int l = 1, r = 1;     // size of array    int n = a.Length;     // function call to find maximum cost    Console.WriteLine(maxCost(a, n, l, r));}} // This code is contributed// by inder_verma
<script> // Javascript program to find maximum cost after// deleting all the elements form the array // function to return maximum cost obtainedfunction maxCost(a, n, l, r){     var mx = 0, k;    // find maximum element of the array.    for (var i = 0; i < n; ++i)        mx = Math.max(mx, a[i]);     // initialize count of all elements to zero.    var count = new Array(mx + 1);    count.fill(0);     // calculate frequency of all elements of array.    for (var i = 0; i < n; i++)        count[a[i]]++;     // stores cost of deleted elements.    var res = new Array(mx + 1);    res[0] = 0;     // selecting minimum range from L and R.    l = Math.min(l, r);     for (var num = 1; num <= mx; num++) {         // finds upto which elements are to be        // deleted when element num is selected.        k = Math.max(num - l - 1, 0);         // get maximum when selecting element num or not.        res[num] = Math.max(res[num - 1],        num * count[num] + res[k]);    }     return res[mx];} var a = [ 2, 1, 2, 3, 2, 2, 1 ];var l = 1, r = 1;// size of arrayvar n = a.length; // function call to find maximum costdocument.write(maxCost(a, n, l, r)); // This code is contributed by SoumikMondal </script>
8
 
Time Complexity: O(max(A)) 
ankthon
ukasp
inderDuMCA
SoumikMondal
array-range-queries
Arrays
Dynamic Programming
Arrays
Dynamic Programming
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Window Sliding Technique
Trapping Rain Water
Reversal algorithm for array rotation
Move all negative numbers to beginning and positive to end with constant extra space
Program to find sum of elements in a given array
0-1 Knapsack Problem | DP-10
Program for Fibonacci numbers
Longest Common Subsequence | DP-4
Bellman–Ford Algorithm | DP-23
Floyd Warshall Algorithm | DP-16