Given an array **arr[]** of size **N**, the task is to find the minimum possible sum by extracting the smallest element from any **K** subsequences from **arr[]** of length **L** such that each of the subsequences have no shared element. If it is not possible to get the required sum, print -1.

**Examples:**

Input:arr[] = {2, 15, 5, 1, 35, 16, 67, 10}, K = 3, L = 2Output:8Explanation:

Three subsequences of length 2 can be {1, 35}, {2, 15}, {5, 16}

Minimum element of {1, 35} is 1.

Minimum element of {2, 15} is 2.

Minimum element of {5, 16} is 5.

Their Sum is equal to 8 which is the minimum possible.

Input:arr[] = {19, 11, 21, 16, 22, 18, 14, 12}, K = 3, L = 3Output:-1Explanation:

It is not possible to construct 3 subsequences of length 3 from arr[].

**Approach:**

To optimize the above approach, we need to observe the following details:

- The
**K**smallest elements of the array contribute to finding the minimum sum of the smallest elements of K subsequences. - The length of the array must be greater than or equal to (K * L) in order to form K subsequences of length L.

Follow the steps below to solve the problem:

- Check if the size of the array
**arr[]**is greater than equal to**(K * L)**. - If so, sort the array
**arr[]**and print the sum of the first**K**elements of the array after sorting. - Otherwise, return -1.

Below is the implementation of the above approach:

## C++

`// C++ Program to find the minimum` `// possible sum of the smallest` `// elements from K subsequences` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to find the minimum sum` `int` `findMinSum(` `int` `arr[], ` `int` `K,` ` ` `int` `L, ` `int` `size)` `{` ` ` `if` `(K * L > size)` ` ` `return` `-1;` ` ` `int` `minsum = 0;` ` ` `// Sort the array` ` ` `sort(arr, arr + size);` ` ` `// Calculate sum of smallest` ` ` `// K elements` ` ` `for` `(` `int` `i = 0; i < K; i++)` ` ` `minsum += arr[i];` ` ` `// Return the sum` ` ` `return` `minsum;` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `arr[] = { 2, 15, 5, 1,` ` ` `35, 16, 67, 10 };` ` ` `int` `K = 3;` ` ` `int` `L = 2;` ` ` `int` `length = ` `sizeof` `(arr)` ` ` `/ ` `sizeof` `(arr[0]);` ` ` `cout << findMinSum(arr, K,` ` ` `L, length);` ` ` `return` `0;` `}` |

## Java

`// Java program to find the minimum` `// possible sum of the smallest` `// elements from K subsequences` `import` `java.util.Arrays;` `class` `GFG{` `// Function to find the minimum sum` `static` `int` `findMinSum(` `int` `[]arr, ` `int` `K,` ` ` `int` `L, ` `int` `size)` `{` ` ` `if` `(K * L > size)` ` ` `return` `-` `1` `;` ` ` `int` `minsum = ` `0` `;` ` ` `// Sort the array` ` ` `Arrays.sort(arr);` ` ` `// Calculate sum of smallest` ` ` `// K elements` ` ` `for` `(` `int` `i = ` `0` `; i < K; i++)` ` ` `minsum += arr[i];` ` ` `// Return the sum` ` ` `return` `minsum;` `}` `// Driver Code` `public` `static` `void` `main(String args[])` `{` ` ` `int` `arr[] = { ` `2` `, ` `15` `, ` `5` `, ` `1` `,` ` ` `35` `, ` `16` `, ` `67` `, ` `10` `};` ` ` `int` `K = ` `3` `;` ` ` `int` `L = ` `2` `;` ` ` `int` `length = arr.length;` ` ` `System.out.print(findMinSum(arr, K,` ` ` `L, length));` `}` `}` `// This code is contributed by Ritik Bansal` |

## Python3

`# Python3 program to find the minimum` `# possible sum of the smallest` `# elements from K subsequences` `# Function to find the minimum sum` `def` `findMinSum(arr, K, L, size):` ` ` `if` `(K ` `*` `L > size):` ` ` `return` `-` `1` ` ` `minsum ` `=` `0` ` ` `# Sort the array` ` ` `arr.sort()` ` ` `# Calculate sum of smallest` ` ` `# K elements` ` ` `for` `i ` `in` `range` `(K):` ` ` `minsum ` `+` `=` `arr[i]` ` ` `# Return the sum` ` ` `return` `minsum` `# Driver code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` `arr ` `=` `[` `2` `, ` `15` `, ` `5` `, ` `1` `,` ` ` `35` `, ` `16` `, ` `67` `, ` `10` `]` ` ` `K ` `=` `3` ` ` `L ` `=` `2` ` ` `length ` `=` `len` `(arr)` ` ` `print` `(findMinSum(arr, K, L, length))` `# This code is contributed by Shivam Singh` |

## C#

`// C# program to find the minimum` `// possible sum of the smallest` `// elements from K subsequences` `using` `System;` ` ` `class` `GFG{` ` ` `// Function to find the minimum sum` `static` `int` `findMinSum(` `int` `[]arr, ` `int` `K,` ` ` `int` `L, ` `int` `size)` `{` ` ` `if` `(K * L > size)` ` ` `return` `-1;` ` ` ` ` `int` `minsum = 0;` ` ` ` ` `// Sort the array` ` ` `Array.Sort(arr); ` ` ` ` ` `// Calculate sum of smallest` ` ` `// K elements` ` ` `for` `(` `int` `i = 0; i < K; i++)` ` ` `minsum += arr[i];` ` ` ` ` `// Return the sum` ` ` `return` `minsum;` `}` ` ` `// Driver Code` `public` `static` `void` `Main() ` `{` ` ` `int` `[] arr = { 2, 15, 5, 1,` ` ` `35, 16, 67, 10 };` ` ` `int` `K = 3;` ` ` `int` `L = 2;` ` ` `int` `length = arr.Length;` ` ` ` ` `Console.Write(findMinSum(arr, K,` ` ` `L, length));` `}` `}` `// This code is contributed by code_hunt` |

**Output**

8

**Time Complexity:** O(N * log(N)) **Space Complexity:** O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend live classes with industry experts, please refer **Geeks Classes Live** and **Geeks Classes Live USA**