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

• Difficulty Level : Expert
• Last Updated : 12 Jun, 2021

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);``}`

Output:

`7`

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

My Personal Notes arrow_drop_up