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

• Last Updated : 13 May, 2021

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 ``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`

## Javascript

 ``

Output:

`3`

Time Complexity: O(1)

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up