Maximize the sum of differences of consecutive elements after removing exactly K elements

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: 3 
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: 0 

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++ 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 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 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# 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 

<script>

// Javascript implementation of the approach

// Function to return the maximized sum
function findSum(arr, n, k)
{

    // Remove any k internal elements
    if (k <= n - 2)
        return (arr[n - 1] - arr[0]);

    return 0;
}

// Driver code
var arr = [1, 2, 3, 4];
var n = arr.length;
var k = 1;
document.write( findSum(arr, n, k));

</script> 

3

Time Complexity: O(1)

Auxiliary Space: O(1)