Open in App
Not now

# Minimum cost required to convert all Subarrays of size K to a single element

• Difficulty Level : Expert
• Last Updated : 18 Mar, 2023

Prerequisite: Sliding Window Median
Given an array arr[] consisting of N integers and an integer K, the task is to find the minimum cost required to make each element of every subarray of length K equal. Cost of replacing any array element by another element is the absolute difference between the two.
Examples:

Input: A[] = {1, 2, 3, 4, 6}, K = 3
Output:
Explanation:
Subarray 1: Cost to convert subarray {1, 2, 3} to {2, 2, 2} = |1-2| + |2-2| + |3-2| = 2
Subarray 2: Cost to convert subarray {2, 3, 4} to {3, 3, 3} = |2-3| + |3-3| + |4-3| = 2
Subarray 3: Cost to convert subarray {3, 4, 6} to {4, 4, 4} = |3-4| + |4-4| + |6-4| = 3
Minimum Cost = 2 + 2 + 3 = 7/
Input: A[] = {2, 3, 4, 4, 1, 7, 6}, K = 4
Output: 21

Approach:
To find the minimum cost to convert each element of the subarray to a single element, change every element of the subarray to the median of that subarray. Follow the steps below to solve the problem:

• To find the median for each running subarray efficiently, use a multiset to get the sorted order of elements in each subarray. Median will be the middle element of this multiset.
• For the next subarray remove the leftmost element of the previous subarray from the multiset, add the current element to the multiset.
• Keep a pointer mid to efficiently keep track of the middle element of the multiset.
• If the newly added element is smaller than the previous middle element, move mid to its immediate smaller element. Otherwise, move mid to its immediate next element.
• Calculate cost of replacing every element of the subarray by the equation | A[i] – medianeach_subarray |.
• Finally print the total cost.

Below is the implementation for the above approach:

## C++

 `// C++ Program to implement` `// the above approach` `#include ` `using` `namespace` `std;`   `// Function to find the minimum` `// cost to convert each element of` `// every subarray of size K equal` `int` `minimumCost(vector<``int``> arr, ``int` `n,` `                ``int` `k)` `{` `    ``// Stores the minimum cost` `    ``int` `totalcost = 0;` `    ``int` `i, j;`   `    ``// Stores the first K elements` `    ``multiset<``int``> mp(arr.begin(),` `                     ``arr.begin() + k);`   `    ``if` `(k == n) {`   `        ``// Obtain the middle element of` `        ``// the multiset` `        ``auto` `mid = next(mp.begin(),` `                        ``n / 2 - ((k + 1) % 2));`   `        ``int` `z = *mid;`   `        ``// Calculate cost for the subarray` `        ``for` `(i = 0; i < n; i++)` `            ``totalcost += ``abs``(z - arr[i]);`   `        ``// Return the total cost` `        ``return` `totalcost;` `    ``}` `    ``else` `{`   `        ``// Obtain the middle element` `        ``// in multiset` `        ``auto` `mid = next(mp.begin(),` `                        ``k / 2 - ((k + 1) % 2));`   `        ``for` `(i = k; i < n; i++) {`   `            ``int` `zz = *mid;` `            ``int` `cost = 0;` `            ``for` `(j = i - k; j < i; j++) {`   `                ``// Cost for the previous` `                ``// k length subarray` `                ``cost += ``abs``(arr[j] - zz);` `            ``}` `            ``totalcost += cost;`   `            ``// Insert current element` `            ``// into multiset` `            ``mp.insert(arr[i]);`   `            ``if` `(arr[i] < *mid) {`   `                ``// New element appears` `                ``// to the left of mid` `                ``mid--;` `            ``}`   `            ``if` `(arr[i - k] <= *mid) {`   `                ``// New element appears` `                ``// to the right of mid` `                ``mid++;` `            ``}`   `            ``// Remove leftmost element` `            ``// from the window` `            ``mp.erase(mp.lower_bound(arr[i - k]));`   `            ``// For last element` `            ``if` `(i == n - 1) {` `                ``zz = *mid;` `                ``cost = 0;`   `                ``for` `(j = i - k + 1;` `                     ``j <= i; j++) {`   `                    ``// Calculate cost for the subarray` `                    ``cost += ``abs``(zz - arr[j]);` `                ``}`   `                ``totalcost += cost;` `            ``}` `        ``}`   `        ``// Return the total cost` `        ``return` `totalcost;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 5, K = 3;`   `    ``vector<``int``> A({ 1, 2, 3, 4, 6 });`   `    ``cout << minimumCost(A, N, K);` `}`

## Java

 `import` `java.util.*;`   `class` `GFG {`   `  ``// Function to find the minimum` `  ``// cost to convert each element of` `  ``// every subarray of size K equal` `  ``static` `int` `minimumCost(``int``[] arr, ``int` `n, ``int` `k)` `  ``{` `    ``// Stores the minimum cost` `    ``int` `totalcost = ``0``;` `    ``int` `i = ``0``, j = ``0``;`   `    ``// Stores the first K elements` `    ``List mp = ``new` `ArrayList();` `    ``for` `(``int` `x = ``0``; x < k; x++) {` `      ``mp.add(arr[x]);` `    ``}` `    ``Collections.sort(mp);`   `    ``if` `(k == n) {` `      ``// Obtain the middle element of` `      ``// the list` `      ``int` `mid = mp.get(n / ``2` `- ((k + ``1``) % ``2``));` `      ``int` `z = mid;`   `      ``// Calculate cost for the subarray` `      ``for` `(i = ``0``; i < n; i++) {` `        ``totalcost += Math.abs(z - arr[i]);` `      ``}`   `      ``// Return the total cost` `      ``return` `totalcost;` `    ``}` `    ``else` `{` `      ``// Obtain the middle element in the list` `      ``int` `mid = mp.get(k / ``2` `- ((k + ``1``) % ``2``));`   `      ``for` `(i = k; i < n; i++) {` `        ``int` `zz = mid;` `        ``int` `cost = ``0``;` `        ``for` `(j = i - k; j < i; j++) {` `          ``// Cost for the previous` `          ``// k length subarray` `          ``cost += Math.abs(arr[j] - zz);` `        ``}` `        ``totalcost += cost;`   `        ``// Insert current element` `        ``// into the list` `        ``int` `idx` `          ``= Collections.binarySearch(mp, arr[i]);` `        ``if` `(idx < ``0``) {` `          ``mp.add(-idx - ``1``, arr[i]);` `        ``}` `        ``else` `{` `          ``mp.add(idx, arr[i]);` `        ``}`   `        ``if` `(arr[i] < mid) {` `          ``// New element appears` `          ``// to the left of mid` `          ``mid = mp.get(k / ``2` `- ((k + ``1``) % ``2``));` `        ``}`   `        ``if` `(arr[i - k] <= mid) {` `          ``// New element appears` `          ``// to the right of mid` `          ``mid = mp.get(k / ``2` `- ((k + ``1``) % ``2``) + ``1``);` `        ``}`   `        ``// Remove leftmost element` `        ``// from the window` `        ``idx = Collections.binarySearch(mp,` `                                       ``arr[i - k]);` `        ``if` `(idx >= ``0``) {` `          ``mp.remove(idx);` `        ``}`   `        ``// For last element` `        ``if` `(i == n - ``1``) {` `          ``zz = mid;` `          ``cost = ``0``;` `          ``for` `(j = i - k + ``1``; j < i + ``1``; j++) {` `            ``// Calculate cost for the subarray` `            ``cost += Math.abs(zz - arr[j]);` `          ``}` `          ``totalcost += cost;` `        ``}` `      ``}`   `      ``// Return the total cost` `      ``return` `totalcost;` `    ``}` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int` `N = ``5``, K = ``3``;` `    ``int``[] A = { ``1``, ``2``, ``3``, ``4``, ``6` `};` `    ``System.out.println(minimumCost(A, N, K));` `  ``}` `}`   `// This code is contributed by phasing17.`

## Python3

 `import` `bisect`   `# Function to find the minimum` `# cost to convert each element of` `# every subarray of size K equal` `def` `minimumCost(arr, n, k):` `    ``# Stores the minimum cost` `    ``totalcost ``=` `0` `    ``i, j ``=` `0``, ``0`   `    ``# Stores the first K elements` `    ``mp ``=` `sorted``(arr[:k])`   `    ``if` `k ``=``=` `n:` `        ``# Obtain the middle element of` `        ``# the list` `        ``mid ``=` `mp[n ``/``/` `2` `-` `((k ``+` `1``) ``%` `2``)]` `        ``z ``=` `mid`   `        ``# Calculate cost for the subarray` `        ``for` `i ``in` `range``(n):` `            ``totalcost ``+``=` `abs``(z ``-` `arr[i])`   `        ``# Return the total cost` `        ``return` `totalcost` `    ``else``:` `        ``# Obtain the middle element in the list` `        ``mid ``=` `mp[k ``/``/` `2` `-` `((k ``+` `1``) ``%` `2``)]`   `        ``for` `i ``in` `range``(k, n):` `            ``zz ``=` `mid` `            ``cost ``=` `0` `            ``for` `j ``in` `range``(i ``-` `k, i):` `                ``# Cost for the previous` `                ``# k length subarray` `                ``cost ``+``=` `abs``(arr[j] ``-` `zz)` `            ``totalcost ``+``=` `cost`   `            ``# Insert current element` `            ``# into the list` `            ``bisect.insort(mp, arr[i])`   `            ``if` `arr[i] < mid:` `                ``# New element appears` `                ``# to the left of mid` `                ``mid ``=` `mp[k ``/``/` `2` `-` `((k ``+` `1``) ``%` `2``)]`   `            ``if` `arr[i ``-` `k] <``=` `mid:` `                ``# New element appears` `                ``# to the right of mid` `                ``mid ``=` `mp[k ``/``/` `2` `-` `((k ``+` `1``) ``%` `2``) ``+` `1``]`   `            ``# Remove leftmost element` `            ``# from the window` `            ``idx ``=` `bisect.bisect_left(mp, arr[i ``-` `k])` `            ``mp.pop(idx)`   `            ``# For last element` `            ``if` `i ``=``=` `n ``-` `1``:` `                ``zz ``=` `mid` `                ``cost ``=` `0` `                ``for` `j ``in` `range``(i ``-` `k ``+` `1``, i ``+` `1``):` `                    ``# Calculate cost for the subarray` `                    ``cost ``+``=` `abs``(zz ``-` `arr[j])` `                ``totalcost ``+``=` `cost`   `        ``# Return the total cost` `        ``return` `totalcost`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``N, K ``=` `5``, ``3` `    ``A ``=` `[``1``, ``2``, ``3``, ``4``, ``6``]` `    ``print``(minimumCost(A, N, K))`   `    ``# This code is contributed by phasing17.`

## Javascript

 `// Javascript program for the above approach`   `// Function to find the minimum cost to convert each ` `// element of every subarray of size K equal` `function` `minimumCost(arr, n, k) {` `  ``// Stores the minimum cost` `  ``let totalcost = 0;` `  ``let i = 0,` `    ``j = 0;`   `  ``// Stores the first K elements` `  ``let mp = arr.slice(0, k).sort((a, b) => a - b);`   `  ``if` `(k == n) {` `    ``// Obtain the middle element of the list` `    ``let mid = mp[Math.floor(n / 2) - ((k + 1) % 2)];` `    ``let z = mid;`   `    ``// Calculate cost for the subarray` `    ``for` `(let i = 0; i < n; i++) {` `      ``totalcost += Math.abs(z - arr[i]);` `    ``}`   `    ``// Return the total cost` `    ``return` `totalcost;` `  ``} ``else` `{` `    ``// Obtain the middle element in the list` `    ``let mid = mp[Math.floor(k / 2) - ((k + 1) % 2)];`   `    ``for` `(let i = k; i < n; i++) {` `      ``let zz = mid;` `      ``let cost = 0;` `      ``for` `(let j = i - k; j < i; j++) {` `        ``// Cost for the previous k length subarray` `        ``cost += Math.abs(arr[j] - zz);` `      ``}` `      ``totalcost += cost;`   `      ``// Insert current element into the list` `      ``mp.splice(bisect_left(mp, arr[i]), 0, arr[i]);`   `      ``if` `(arr[i] < mid) {` `        ``// New element appears to the left of mid` `        ``mid = mp[Math.floor(k / 2) - ((k + 1) % 2)];` `      ``}`   `      ``if` `(arr[i - k] <= mid) {` `        ``// New element appears to the right of mid` `        ``mid = mp[Math.floor(k / 2) - ((k + 1) % 2) + 1];` `      ``}`   `      ``// Remove leftmost element from the window` `      ``mp.splice(bisect_left(mp, arr[i - k]), 1);`   `      ``// For last element` `      ``if` `(i == n - 1) {` `        ``zz = mid;` `        ``cost = 0;` `        ``for` `(let j = i - k + 1; j <= i; j++) {` `          ``// Calculate cost for the subarray` `          ``cost += Math.abs(zz - arr[j]);` `        ``}` `        ``totalcost += cost;` `      ``}` `    ``}`   `    ``// Return the total cost` `    ``return` `totalcost;` `  ``}` `}`   `// Driver Code` `let N = 5,` `  ``K = 3;` `let A = [1, 2, 3, 4, 6];` `console.log(minimumCost(A, N, K));`   `// Returns the index at which the element should be inserted into the sorted list` `function` `bisect_left(arr, x) {` `  ``let lo = 0,` `    ``hi = arr.length;` `  ``while` `(lo < hi) {` `    ``let mid = Math.floor((lo + hi) / 2);` `    ``if` `(arr[mid] < x) lo = mid + 1;` `    ``else` `hi = mid;` `  ``}` `  ``return` `lo;` `}`   `// contributed by adityasharmadev01`

## C#

 `// C# Equivalent` `using` `System;` `using` `System.Collections.Generic;` ` `  `public` `class` `GFG` `{` `    ``// Function to find the minimum` `    ``// cost to convert each element of` `    ``// every subarray of size K equal` `    ``static` `int` `minimumCost(``int``[] arr, ``int` `n, ``int` `k)` `    ``{` `        ``// Stores the minimum cost` `        ``int` `totalcost = 0;` `        ``int` `i = 0, j = 0;` ` `  `        ``// Stores the first K elements` `        ``List<``int``> mp = ``new` `List<``int``>();` `        ``for` `(``int` `x = 0; x < k; x++)` `        ``{` `            ``mp.Add(arr[x]);` `        ``}` `        ``mp.Sort();` ` `  `        ``if` `(k == n)` `        ``{` `            ``// Obtain the middle element of` `            ``// the list` `            ``int` `mid = mp[n / 2 - (k + 1) % 2];` `            ``int` `z = mid;` ` `  `            ``// Calculate cost for the subarray` `            ``for` `(i = 0; i < n; i++)` `            ``{` `                ``totalcost += Math.Abs(z - arr[i]);` `            ``}` ` `  `            ``// Return the total cost` `            ``return` `totalcost;` `        ``}` `        ``else` `        ``{` `            ``// Obtain the middle element in the list` `            ``int` `mid = mp[k / 2 - (k + 1) % 2];` ` `  `            ``for` `(i = k; i < n; i++)` `            ``{` `                ``int` `zz = mid;` `                ``int` `cost = 0;` `                ``for` `(j = i - k; j < i; j++)` `                ``{` `                    ``// Cost for the previous` `                    ``// k length subarray` `                    ``cost += Math.Abs(arr[j] - zz);` `                ``}` `                ``totalcost += cost;` ` `  `                ``// Insert current element` `                ``// into the list` `                ``int` `idx = mp.BinarySearch(arr[i]);` `                ``if` `(idx < 0)` `                ``{` `                    ``mp.Insert(-idx - 1, arr[i]);` `                ``}` `                ``else` `                ``{` `                    ``mp.Insert(idx, arr[i]);` `                ``}` ` `  `                ``if` `(arr[i] < mid)` `                ``{` `                    ``// New element appears` `                    ``// to the left of mid` `                    ``mid = mp[k / 2 - (k + 1) % 2];` `                ``}` ` `  `                ``if` `(arr[i - k] <= mid)` `                ``{` `                    ``// New element appears` `                    ``// to the right of mid` `                    ``mid = mp[k / 2 - (k + 1) % 2 + 1];` `                ``}` ` `  `                ``// Remove leftmost element` `                ``// from the window` `                ``idx = mp.BinarySearch(arr[i - k]);` `                ``if` `(idx >= 0)` `                ``{` `                    ``mp.RemoveAt(idx);` `                ``}` ` `  `                ``// For last element` `                ``if` `(i == n - 1)` `                ``{` `                    ``zz = mid;` `                    ``cost = 0;` `                    ``for` `(j = i - k + 1; j < i + 1; j++)` `                    ``{` `                        ``// Calculate cost for the subarray` `                        ``cost += Math.Abs(zz - arr[j]);` `                    ``}` `                    ``totalcost += cost;` `                ``}` `            ``}` ` `  `            ``// Return the total cost` `            ``return` `totalcost;` `        ``}` `    ``}` ` `  `    ``// Driver Code` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``int` `N = 5, K = 3;` `        ``int``[] A = { 1, 2, 3, 4, 6 };` `        ``Console.Write(minimumCost(A, N, K));` `    ``}` `}`

Output:

`7`

Time Complexity: O(NlogN)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles