Related Articles
Minimum cost required to convert all Subarrays of size K to a single element
• Difficulty Level : Expert
• Last Updated : 07 Aug, 2020

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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.
• Calaculate 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);``}`
Output:
```7
```

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

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. 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