# Minimum sum of medians of all possible K length subsequences of a sorted array

• Last Updated : 13 Sep, 2021

Given a sorted array arr[] consisting of N integers and a positive integer K(such that N%K is 0), the task is to find the minimum sum of the medians of all possible subsequences of size K such that each element belongs to only one subsequence.

Examples:

Input: arr[] = {1, 2, 3, 4, 5, 6}, K = 2
Output: 6
Explanation:
Consider the subsequences of size K as {1, 4}, {2, 5}, and {3, 6}.
The sum of medians of all the subsequences is (1 + 2 + 3) = 6 which is the minimum possible sum.

Input: K = 3, arr[] = {3, 11, 12, 22, 33, 35, 38, 67, 69, 71, 94, 99}, K = 3
Output: 135

Naive Approach: The given problem can be solved by generating all possible K-sized sorted subsequences and print the median of all those subsequences as the result.

Time Complexity: O(2N)
Auxiliary Space: O(1)

Efficient Approach: The above approach can also be optimized by using the Greedy Approach for the construction of all the subsequences. The idea is to select K/2 elements from starting of the array and K/2 elements from the ending of the array such that the median always occurs in the first part. Follow the steps below to solve the problem:

• Initialize a variable, say res that stores the resultant sum of medians.
• Initialize a variable, say T as N/K to store the number of subsequences required and a variable D as (K + 1)/2 to store the distance between the medians.
• Initialize a variable, say i as (D – 1) to store the index of the first median to be added to the result.
• Iterate until the value of i < N and T > 0, and perform the following steps:
• Add the value of arr[i] to the variable res.
• Increment the value of i by D to get the index of the next median.
• Decrement the value of T by 1.
• After completing the above steps, print the value of res as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the minimum sum of``// all the medians of the K sized sorted``// arrays formed from the given array``void` `sumOfMedians(``int` `arr[], ``int` `N,``                  ``int` `K)``{``    ``// Stores the distance between``    ``// the medians``    ``int` `selectMedian = (K + 1) / 2;` `    ``// Stores the number of subsequences``    ``// required``    ``int` `totalArrays = N / K;` `    ``// Stores the resultant sum``    ``int` `minSum = 0;` `    ``// Iterate from start and add``    ``// all the medians``    ``int` `i = selectMedian - 1;``    ``while` `(i < N and totalArrays != 0) {` `        ``// Add the value of arr[i]``        ``// to the variable minsum``        ``minSum = minSum + arr[i];` `        ``// Increment i by select the``        ``// median to get the next``        ``// median index``        ``i = i + selectMedian;` `        ``// Decrement the value of``        ``// totalArrays by 1``        ``totalArrays--;``    ``}` `    ``// Print the resultant minimum sum``    ``cout << minSum;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 1, 2, 3, 4, 5, 6 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(``int``);``    ``int` `K = 2;``    ``sumOfMedians(arr, N, K);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;` `public` `class` `GFG {` `    ``// Function to find the minimum sum of``    ``// all the medians of the K sized sorted``    ``// arrays formed from the given array``    ``static` `void` `sumOfMedians(``int` `arr[], ``int` `N, ``int` `K)``    ``{``        ``// Stores the distance between``        ``// the medians``        ``int` `selectMedian = (K + ``1``) / ``2``;` `        ``// Stores the number of subsequences``        ``// required``        ``int` `totalArrays = N / K;` `        ``// Stores the resultant sum``        ``int` `minSum = ``0``;` `        ``// Iterate from start and add``        ``// all the medians``        ``int` `i = selectMedian - ``1``;``        ``while` `(i < N && totalArrays != ``0``) {` `            ``// Add the value of arr[i]``            ``// to the variable minsum``            ``minSum = minSum + arr[i];` `            ``// Increment i by select the``            ``// median to get the next``            ``// median index``            ``i = i + selectMedian;` `            ``// Decrement the value of``            ``// totalArrays by 1``            ``totalArrays--;``        ``}` `        ``// Print the resultant minimum sum``        ``System.out.println(minSum);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = { ``1``, ``2``, ``3``, ``4``, ``5``, ``6` `};``        ``int` `N = arr.length;``        ``int` `K = ``2``;``        ``sumOfMedians(arr, N, K);``    ``}``}` `// This code is contributed by Kingash.`

## Python3

 `# Python3 program for the above approach` `# Function to find the minimum sum of``# all the medians of the K sized sorted``# arrays formed from the given array``def` `sumOfMedians(arr, N, K):` `    ``# Stores the distance between``    ``# the medians``    ``selectMedian ``=` `(K ``+` `1``) ``/``/` `2` `    ``# Stores the number of subsequences``    ``# required``    ``totalArrays ``=` `N ``/``/` `K` `    ``# Stores the resultant sum``    ``minSum ``=` `0` `    ``# Iterate from start and add``    ``# all the medians``    ``i ``=` `selectMedian ``-` `1``    ` `    ``while` `(i < N ``and` `totalArrays !``=` `0``):` `        ``# Add the value of arr[i]``        ``# to the variable minsum``        ``minSum ``=` `minSum ``+` `arr[i]` `        ``# Increment i by select the``        ``# median to get the next``        ``# median index``        ``i ``=` `i ``+` `selectMedian` `        ``# Decrement the value of``        ``# totalArrays by 1``        ``totalArrays ``-``=` `1` `     ``# Print the resultant minimum sum``    ``print``(minSum)` ` ``# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[ ``1``, ``2``, ``3``, ``4``, ``5``, ``6` `]``    ``N ``=` `len``(arr)``    ``K ``=` `2``    ` `    ``sumOfMedians(arr, N, K)` `# This code is contributed by nirajgsuain5`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;`` ` `class` `GFG{`` ` `    ``// Function to find the minimum sum of``    ``// all the medians of the K sized sorted``    ``// arrays formed from the given array``    ``static` `void` `sumOfMedians(``int``[] arr, ``int` `N, ``int` `K)``    ``{``      ` `        ``// Stores the distance between``        ``// the medians``        ``int` `selectMedian = (K + 1) / 2;`` ` `        ``// Stores the number of subsequences``        ``// required``        ``int` `totalArrays = N / K;`` ` `        ``// Stores the resultant sum``        ``int` `minSum = 0;`` ` `        ``// Iterate from start and add``        ``// all the medians``        ``int` `i = selectMedian - 1;``        ``while` `(i < N && totalArrays != 0) {`` ` `            ``// Add the value of arr[i]``            ``// to the variable minsum``            ``minSum = minSum + arr[i];`` ` `            ``// Increment i by select the``            ``// median to get the next``            ``// median index``            ``i = i + selectMedian;`` ` `            ``// Decrement the value of``            ``// totalArrays by 1``            ``totalArrays--;``        ``}`` ` `        ``// Print the resultant minimum sum``        ``Console.WriteLine(minSum);``    ``}`` ` `// Driver Code``public` `static` `void` `Main()``{``        ``int``[] arr = { 1, 2, 3, 4, 5, 6 };``        ``int` `N = arr.Length;``        ``int` `K = 2;``        ``sumOfMedians(arr, N, K);``     ` `}``}` `// This code is contributed by code_hunt.`

## Javascript

 ``

Output:

`6`

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

My Personal Notes arrow_drop_up