Skip to content
Related Articles

Related Articles

Maximize the sum of differences of consecutive elements after removing exactly K elements
  • Last Updated : 12 Mar, 2021
GeeksforGeeks - Summer Carnival Banner

Given a sorted array arr[] of length N and an integer K such that K < N, the task is to remove exactly K elements from the array such that the sum of the differences of the consecutive elements of the array is maximized.
Examples: 

Input: arr[] = {1, 2, 3, 4}, K = 1 
Output:
Let’s consider all the possible cases: 
a) Remove arr[0]: arr[] = {2, 3, 4}, ans = 2 
b) Remove arr[1]: arr[] = {1, 3, 4}, ans = 3 
c) Remove arr[2]: arr[] = {1, 2, 4}, ans = 3 
d) Remove arr[3]: arr[] = {1, 2, 3}, ans = 2 
3 is the maximum of all the answers.
Input: arr[] = {1, 2, 10}, K = 2 
Output:

Approach: There are two cases:  

  1. If K < N – 1 then the answer will be arr[N – 1] – arr[0]. This is because any K elements from the N – 2 internal elements of the array can be deleted without affecting the maximized sum of differences. For example, if any single element has to be removed from 1, 2, 3 and 4 then no matter whether 2 is removed or 3 is removed the final sum of difference will remain the same i.e. ((3 – 1) + (4 – 3)) = 3 which is equal to ((2 – 1) + (4 – 2)) = 3.
  2. If K = N – 1 then the answer will be 0 because only a single element remains that is both the minimum and the maximum. Thus, the answer is 0.

Below is the implementation of the above approach:  

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the maximized sum
int findSum(int* arr, int n, int k)
{
 
    // Remove any k internal elements
    if (k <= n - 2)
        return (arr[n - 1] - arr[0]);
 
    return 0;
}
 
// Driver code
int main()
{
    int arr[] = { 1, 2, 3, 4 };
    int n = sizeof(arr) / sizeof(int);
    int k = 1;
 
    cout << findSum(arr, n, k);
 
    return 0;
}

Java




// Java implementation of the approach
class GFG
{
     
    // Function to return the maximized sum
    static int findSum(int []arr, int n, int k)
    {
     
        // Remove any k internal elements
        if (k <= n - 2)
            return (arr[n - 1] - arr[0]);
     
        return 0;
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int arr[] = { 1, 2, 3, 4 };
        int n = arr.length;
        int k = 1;
     
        System.out.println(findSum(arr, n, k));
    }
}
 
// This code is contributed by AnkitRai01

Python3




# Python3 implementation of the approach
 
# Function to return the maximized sum
def findSum(arr, n, k) :
 
    # Remove any k internal elements
    if (k <= n - 2) :
        return (arr[n - 1] - arr[0]);
         
    return 0;
     
# Driver code
if __name__ == "__main__" :
 
    arr = [ 1, 2, 3, 4 ];
    n = len(arr);
    k = 1;
 
    print(findSum(arr, n, k));
     
# This code is contributed by AnkitRai01

C#




// C# implementation of the approach
using System;
 
class GFG
{
     
    // Function to return the maximized sum
    static int findSum(int []arr,
                       int n, int k)
    {
     
        // Remove any k internal elements
        if (k <= n - 2)
            return (arr[n - 1] - arr[0]);
     
        return 0;
    }
     
    // Driver code
    public static void Main ()
    {
        int []arr = { 1, 2, 3, 4 };
        int n = arr.Length;
        int k = 1;
     
        Console.WriteLine(findSum(arr, n, k));
    }
}
 
// This code is contributed by AnkitRai01
Output: 



3

 

Time Complexity: O(1)

Auxiliary Space: O(1)

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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :