# Shortest Subsequence with sum exactly K

Given an array **Arr[] **of size **N** and an integer **K**, the task is to find the length of the shortest subsequence having sum exactly **K**.

**Examples:**

Input:N = 5, K = 4, Arr[] = {1, 2, 2, 3, 4}Output:1Explanation:Here, one can choose the last month and can get 4 working hours.

Input:N = 3, K = 2, Arr[] = {1, 3, 5}Output:-1Explanation:Here, we can not get exactly 2 hours of work from any month.

**Naive Approach: **One of the most basic ways of solving the above problem is to generate all the subsets using Recursion and choose the subset with the smallest size which sums exactly **K**.

* Time complexity:* O (N * 2

^{N}).

*O(1)*

**Auxiliary Space**:**Efficient Approach: ** The above problem can be solved in dynamic programming efficiently in the following way.

On each index there are two choices: either to include the element in the subsequence or not. To efficiently calculate this, use a two dimensional dp[][] array where dp[i][j] stores the minimum length of subsequence with sum j up to ith index.

Follow the below steps to implement the approach:

- Iterate from the start of the array.
- For each element there are two choices: either pick the element or not.
- If the value of the
**ith**element is greater than the required sum (say**X**) to have subsequence sum**K**then it cannot be included. - Otherwise do the following:
- Pick the
**ith**element, update the required sum as**(X-Arr[i])**and recursively do the same for the next index in step 5. - Don’t insert the element in subsequence and call recursively for the next element.
- Store the minimum between these two in the
**dp[][]**array.

- Pick the
- In each recursive call:
- If the required sum is 0 store the length of subsequence in dp[][] array.
- If it is already calculated for this same value of
**i**and**X**it is already calculated then return the same. - If not possible to achieve a subsequence sum exactly
**K**from this state, return**-1**.

- The final value at
**dp[0][K]**will denote the minimum subsequence length.

Below is the implementation of the above approach:

## C++

`// C++ code for the above approach:` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function which returns smallest` `// Subset size which sums exactly K` `// Or else returns -1` `// If there is no such subset` `int` `minSize(vector<vector<` `int` `> >& dp,` ` ` `int` `i, vector<` `int` `>& arr,` ` ` `int` `k, ` `int` `n)` `{` ` ` `// Size of empty subset is zero` ` ` `if` `(k == 0)` ` ` `return` `0;` ` ` `// If the end of the array is reached` ` ` `// and k is not reduced to zero` ` ` `// then there is no subset` ` ` `// gor current value of k` ` ` `if` `(i == n)` ` ` `return` `-1;` ` ` `// If some value of K is present` ` ` `// and it is required to make a choice` ` ` `// either to pick the ith element or` ` ` `// unpick it, and if it is already` ` ` `// computed, Return the answer directly` ` ` `if` `(dp[i][k] != 0)` ` ` `return` `dp[i][k];` ` ` `int` `x, y, maxi;` ` ` `maxi = INT_MAX;` ` ` `// Initialize with maximum value since` ` ` `// it is required to find` ` ` `// the smallest subset` ` ` `x = y = maxi;` ` ` `// If the ith element is less than` ` ` `// or equal to k than` ` ` `// it can be a part of subset` ` ` `if` `(arr[i] <= k) {` ` ` `// Check whether there is a subset` ` ` `// for ( k - arr[i])` ` ` `int` `m = minSize(dp, i + 1, arr,` ` ` `k - arr[i], n);` ` ` `// Check whether m is -1 or not` ` ` `if` `(m != -1) {` ` ` `// If m is not equal to -1` ` ` `// that means there exists a subset` ` ` `// for the value ( k - arr[i] )` ` ` `// update the subset size` ` ` `x = min(x, m + 1);` ` ` `}` ` ` `}` ` ` `// Exclude the current element and` ` ` `// check whether there is a subset for K` ` ` `// by trying the rest of the combinations` ` ` `int` `m = minSize(dp, i + 1, arr, k, n);` ` ` `// Check whether m is not equal to -1` ` ` `if` `(m != -1) {` ` ` `// If m is not equal to -1 than` ` ` `// a subset is found for value` ` ` `// of K so update the` ` ` `// size of the subset` ` ` `y = min(y, m);` ` ` `}` ` ` `// If both x and y are equal` ` ` `// to maximum value, which means there` ` ` `// is no subset for the current value of K` ` ` `// either including the current element` ` ` `// or excluding the current element` ` ` `// In that case store -1 or else` ` ` `// store the minimum of ( x, y)` ` ` `// since we need the smallest subset` ` ` `return` `(dp[i][k]` ` ` `= (x == maxi and y == maxi) ? -1` ` ` `: min(x, y));` `}` `// Function to calculate the` `// required length of subsequence` `int` `seqLength(vector<` `int` `>& arr, ` `int` `k)` `{` ` ` `int` `n = arr.size();` ` ` `// Initialize the dp vector with 0` ` ` `// in order to indicate that there` ` ` `// is no computed answer for any` ` ` `// of the sub problems` ` ` `vector<vector<` `int` `> > dp(n,` ` ` `vector<` `int` `>(k + 1,` ` ` `0));` ` ` `return` `minSize(dp, 0, arr, k, n);` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `N = 5;` ` ` `int` `K = 4;` ` ` `vector<` `int` `> arr = { 1, 2, 2, 3, 4 };` ` ` `// Function call` ` ` `cout << seqLength(arr, K) << endl;` ` ` `return` `0;` `}` |

## Java

`// Java Program of the above approach.` `import` `java.util.*;` `class` `GFG {` ` ` `// Function which returns smallest` ` ` `// Subset size which sums exactly K` ` ` `// Or else returns -1` ` ` `// If there is no such subset` ` ` `static` `int` `minSize(` `int` `[][] dp, ` `int` `i, ` `int` `[] arr, ` `int` `k,` ` ` `int` `n)` ` ` `{` ` ` `// Size of empty subset is zero` ` ` `if` `(k == ` `0` `)` ` ` `return` `0` `;` ` ` `// If the end of the array is reached` ` ` `// and k is not reduced to zero` ` ` `// then there is no subset` ` ` `// gor current value of k` ` ` `if` `(i == n)` ` ` `return` `-` `1` `;` ` ` `// If some value of K is present` ` ` `// and it is required to make a choice` ` ` `// either to pick the ith element or` ` ` `// unpick it, and if it is already` ` ` `// computed, Return the answer directly` ` ` `if` `(dp[i][k] != ` `0` `)` ` ` `return` `dp[i][k];` ` ` `int` `x = ` `0` `, y = ` `0` `, maxi = Integer.MAX_VALUE;` ` ` `// Initialize with maximum value since` ` ` `// it is required to find` ` ` `// the smallest subset` ` ` `x = y = maxi;` ` ` `// If the ith element is less than` ` ` `// or equal to k than` ` ` `// it can be a part of subset` ` ` `if` `(arr[i] <= k) {` ` ` `// Check whether there is a subset` ` ` `// for ( k - arr[i])` ` ` `int` `m1 = minSize(dp, i + ` `1` `, arr, k - arr[i], n);` ` ` `// Check whether m is -1 or not` ` ` `if` `(m1 != -` `1` `) {` ` ` `// If m is not equal to -1` ` ` `// that means there exists a subset` ` ` `// for the value ( k - arr[i] )` ` ` `// update the subset size` ` ` `x = Math.min(x, m1 + ` `1` `);` ` ` `}` ` ` `}` ` ` `// Exclude the current element and` ` ` `// check whether there is a subset for K` ` ` `// by trying the rest of the combinations` ` ` `int` `m2 = minSize(dp, i + ` `1` `, arr, k, n);` ` ` `// Check whether m is not equal to -1` ` ` `if` `(m2 != -` `1` `) {` ` ` `// If m is not equal to -1 than` ` ` `// a subset is found for value` ` ` `// of K so update the` ` ` `// size of the subset` ` ` `y = Math.min(y, m2);` ` ` `}` ` ` `// If both x and y are equal` ` ` `// to maximum value, which means there` ` ` `// is no subset for the current value of K` ` ` `// either including the current element` ` ` `// or excluding the current element` ` ` `// In that case store -1 or else` ` ` `// store the minimum of ( x, y)` ` ` `// since we need the smallest subset` ` ` `return` `(dp[i][k] = (x == maxi && y == maxi)` ` ` `? -` `1` ` ` `: Math.min(x, y));` ` ` `}` ` ` `// Function to calculate the` ` ` `// required length of subsequence` ` ` `static` `int` `seqLength(` `int` `[] arr, ` `int` `k)` ` ` `{` ` ` `int` `n = arr.length;` ` ` `// Initialize the dp vector with 0` ` ` `// in order to indicate that there` ` ` `// is no computed answer for any` ` ` `// of the sub problems` ` ` `int` `[][] dp = ` `new` `int` `[n][k + ` `1` `];` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++) {` ` ` `for` `(` `int` `j = ` `0` `; j < k + ` `1` `; j++) {` ` ` `dp[i][j] = ` `0` `;` ` ` `}` ` ` `}` ` ` `return` `minSize(dp, ` `0` `, arr, k, n);` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `main(String args[])` ` ` `{` ` ` `int` `N = ` `5` `;` ` ` `int` `K = ` `4` `;` ` ` `int` `[] arr = { ` `1` `, ` `2` `, ` `2` `, ` `3` `, ` `4` `};` ` ` `// Function call` ` ` `System.out.print(seqLength(arr, K));` ` ` `}` `}` `// This code is contributed by code_hunt.` |

## Python3

`# python3 code for the above approach:` `INT_MAX ` `=` `2147483647` `# Function which returns smallest` `# Subset size which sums exactly K` `# Or else returns -1` `# If there is no such subset` `def` `minSize(dp, i, arr, k, n):` ` ` `# Size of empty subset is zero` ` ` `if` `(k ` `=` `=` `0` `):` ` ` `return` `0` ` ` `# If the end of the array is reached` ` ` `# and k is not reduced to zero` ` ` `# then there is no subset` ` ` `# gor current value of k` ` ` `if` `(i ` `=` `=` `n):` ` ` `return` `-` `1` ` ` `# If some value of K is present` ` ` `# and it is required to make a choice` ` ` `# either to pick the ith element or` ` ` `# unpick it, and if it is already` ` ` `# computed, Return the answer directly` ` ` `if` `(dp[i][k] !` `=` `0` `):` ` ` `return` `dp[i][k]` ` ` `maxi ` `=` `INT_MAX` ` ` `# Initialize with maximum value since` ` ` `# it is required to find` ` ` `# the smallest subset` ` ` `x ` `=` `y ` `=` `maxi` ` ` `# If the ith element is less than` ` ` `# or equal to k than` ` ` `# it can be a part of subset` ` ` `if` `(arr[i] <` `=` `k):` ` ` `# Check whether there is a subset` ` ` `# for ( k - arr[i])` ` ` `m ` `=` `minSize(dp, i ` `+` `1` `, arr, k ` `-` `arr[i], n)` ` ` `# Check whether m is -1 or not` ` ` `if` `(m !` `=` `-` `1` `):` ` ` `# If m is not equal to -1` ` ` `# that means there exists a subset` ` ` `# for the value ( k - arr[i] )` ` ` `# update the subset size` ` ` `x ` `=` `min` `(x, m ` `+` `1` `)` ` ` `# Exclude the current element and` ` ` `# check whether there is a subset for K` ` ` `# by trying the rest of the combinations` ` ` `m ` `=` `minSize(dp, i ` `+` `1` `, arr, k, n)` ` ` `# Check whether m is not equal to -1` ` ` `if` `(m !` `=` `-` `1` `):` ` ` `# If m is not equal to -1 than` ` ` `# a subset is found for value` ` ` `# of K so update the` ` ` `# size of the subset` ` ` `y ` `=` `min` `(y, m)` ` ` `# If both x and y are equal` ` ` `# to maximum value, which means there` ` ` `# is no subset for the current value of K` ` ` `# either including the current element` ` ` `# or excluding the current element` ` ` `# In that case store -1 or else` ` ` `# store the minimum of ( x, y)` ` ` `# since we need the smallest subset` ` ` `dp[i][k] ` `=` `-` `1` `if` `(x ` `=` `=` `maxi ` `and` `y ` `=` `=` `maxi) ` `else` `min` `(x, y)` ` ` `return` `dp[i][k]` `# Function to calculate the` `# required length of subsequence` `def` `seqLength(arr, k):` ` ` `n ` `=` `len` `(arr)` ` ` `# Initialize the dp vector with 0` ` ` `# in order to indicate that there` ` ` `# is no computed answer for any` ` ` `# of the sub problems` ` ` `dp ` `=` `[[` `0` `for` `_ ` `in` `range` `(K` `+` `1` `)] ` `for` `_ ` `in` `range` `(n)]` ` ` `return` `minSize(dp, ` `0` `, arr, k, n)` `# Driver Code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `N ` `=` `5` ` ` `K ` `=` `4` ` ` `arr ` `=` `[` `1` `, ` `2` `, ` `2` `, ` `3` `, ` `4` `]` ` ` `# Function call` ` ` `print` `(seqLength(arr, K))` ` ` `# This code is contributed by rakeshsahni` |

## C#

`// C# code for the above approach:` `using` `System;` `class` `GFG {` ` ` `// Function which returns smallest` ` ` `// Subset size which sums exactly K` ` ` `// Or else returns -1` ` ` `// If there is no such subset` ` ` `static` `int` `minSize(` `int` `[, ] dp, ` `int` `i, ` `int` `[] arr, ` `int` `k,` ` ` `int` `n)` ` ` `{` ` ` `// Size of empty subset is zero` ` ` `if` `(k == 0)` ` ` `return` `0;` ` ` `// If the end of the array is reached` ` ` `// and k is not reduced to zero` ` ` `// then there is no subset` ` ` `// gor current value of k` ` ` `if` `(i == n)` ` ` `return` `-1;` ` ` `// If some value of K is present` ` ` `// and it is required to make a choice` ` ` `// either to pick the ith element or` ` ` `// unpick it, and if it is already` ` ` `// computed, Return the answer directly` ` ` `if` `(dp[i, k] != 0)` ` ` `return` `dp[i, k];` ` ` `int` `x = 0, y = 0, maxi = Int32.MaxValue;` ` ` `// Initialize with maximum value since` ` ` `// it is required to find` ` ` `// the smallest subset` ` ` `x = y = maxi;` ` ` `// If the ith element is less than` ` ` `// or equal to k than` ` ` `// it can be a part of subset` ` ` `if` `(arr[i] <= k) {` ` ` `// Check whether there is a subset` ` ` `// for ( k - arr[i])` ` ` `int` `m1 = minSize(dp, i + 1, arr, k - arr[i], n);` ` ` `// Check whether m is -1 or not` ` ` `if` `(m1 != -1) {` ` ` `// If m is not equal to -1` ` ` `// that means there exists a subset` ` ` `// for the value ( k - arr[i] )` ` ` `// update the subset size` ` ` `x = Math.Min(x, m1 + 1);` ` ` `}` ` ` `}` ` ` `// Exclude the current element and` ` ` `// check whether there is a subset for K` ` ` `// by trying the rest of the combinations` ` ` `int` `m2 = minSize(dp, i + 1, arr, k, n);` ` ` `// Check whether m is not equal to -1` ` ` `if` `(m2 != -1) {` ` ` `// If m is not equal to -1 than` ` ` `// a subset is found for value` ` ` `// of K so update the` ` ` `// size of the subset` ` ` `y = Math.Min(y, m2);` ` ` `}` ` ` `// If both x and y are equal` ` ` `// to maximum value, which means there` ` ` `// is no subset for the current value of K` ` ` `// either including the current element` ` ` `// or excluding the current element` ` ` `// In that case store -1 or else` ` ` `// store the minimum of ( x, y)` ` ` `// since we need the smallest subset` ` ` `return` `(dp[i, k] = (x == maxi && y == maxi)` ` ` `? -1` ` ` `: Math.Min(x, y));` ` ` `}` ` ` `// Function to calculate the` ` ` `// required length of subsequence` ` ` `static` `int` `seqLength(` `int` `[] arr, ` `int` `k)` ` ` `{` ` ` `int` `n = arr.Length;` ` ` `// Initialize the dp vector with 0` ` ` `// in order to indicate that there` ` ` `// is no computed answer for any` ` ` `// of the sub problems` ` ` `int` `[, ] dp = ` `new` `int` `[n, k + 1];` ` ` `for` `(` `int` `i = 0; i < n; i++) {` ` ` `for` `(` `int` `j = 0; j < k + 1; j++) {` ` ` `dp[i, j] = 0;` ` ` `}` ` ` `}` ` ` `return` `minSize(dp, 0, arr, k, n);` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `Main()` ` ` `{` ` ` `int` `N = 5;` ` ` `int` `K = 4;` ` ` `int` `[] arr = { 1, 2, 2, 3, 4 };` ` ` `// Function call` ` ` `Console.WriteLine(seqLength(arr, K));` ` ` `}` `}` `// This code is contributed by Samim Hossain Mondal.` |

## Javascript

`<script>` ` ` `// JavaScript code for the above approach` ` ` `// Function which returns smallest` ` ` `// Subset size which sums exactly K` ` ` `// Or else returns -1` ` ` `// If there is no such subset` ` ` `function` `minSize(dp,` ` ` `i, arr, k, n)` ` ` `{` ` ` `// Size of empty subset is zero` ` ` `if` `(k == 0)` ` ` `return` `0;` ` ` `// If the end of the array is reached` ` ` `// and k is not reduced to zero` ` ` `// then there is no subset` ` ` `// gor current value of k` ` ` `if` `(i == n)` ` ` `return` `-1;` ` ` `// If some value of K is present` ` ` `// and it is required to make a choice` ` ` `// either to pick the ith element or` ` ` `// unpick it, and if it is already` ` ` `// computed, Return the answer directly` ` ` `if` `(dp[i][k] != 0)` ` ` `return` `dp[i][k];` ` ` `let x, y, maxi;` ` ` `maxi = Number.MAX_VALUE;` ` ` `// Initialize with maximum value since` ` ` `// it is required to find` ` ` `// the smallest subset` ` ` `x = y = maxi;` ` ` `// If the ith element is less than` ` ` `// or equal to k than` ` ` `// it can be a part of subset` ` ` `if` `(arr[i] <= k) {` ` ` `// Check whether there is a subset` ` ` `// for ( k - arr[i])` ` ` `let m = minSize(dp, i + 1, arr,` ` ` `k - arr[i], n);` ` ` `// Check whether m is -1 or not` ` ` `if` `(m != -1) {` ` ` `// If m is not equal to -1` ` ` `// that means there exists a subset` ` ` `// for the value ( k - arr[i] )` ` ` `// update the subset size` ` ` `x = Math.min(x, m + 1);` ` ` `}` ` ` `}` ` ` `// Exclude the current element and` ` ` `// check whether there is a subset for K` ` ` `// by trying the rest of the combinations` ` ` `let m = minSize(dp, i + 1, arr, k, n);` ` ` `// Check whether m is not equal to -1` ` ` `if` `(m != -1) {` ` ` `// If m is not equal to -1 than` ` ` `// a subset is found for value` ` ` `// of K so update the` ` ` `// size of the subset` ` ` `y = Math.min(y, m);` ` ` `}` ` ` `// If both x and y are equal` ` ` `// to maximum value, which means there` ` ` `// is no subset for the current value of K` ` ` `// either including the current element` ` ` `// or excluding the current element` ` ` `// In that case store -1 or else` ` ` `// store the minimum of ( x, y)` ` ` `// since we need the smallest subset` ` ` `return` `(dp[i][k]` ` ` `= (x == maxi && y == maxi) ? -1` ` ` `: Math.min(x, y));` ` ` `}` ` ` `// Function to calculate the` ` ` `// required length of subsequence` ` ` `function` `seqLength(arr, k) {` ` ` `let n = arr.length;` ` ` `// Initialize the dp vector with 0` ` ` `// in order to indicate that there` ` ` `// is no computed answer for any` ` ` `// of the sub problems` ` ` `let dp = ` `new` `Array(n)` ` ` `for` `(let i = 0; i < dp.length; i++) {` ` ` `dp[i] = ` `new` `Array(k + 1).fill(0)` ` ` `}` ` ` `return` `minSize(dp, 0, arr, k, n);` ` ` `}` ` ` `// Driver Code` ` ` `let N = 5;` ` ` `let K = 4;` ` ` `let arr = [1, 2, 2, 3, 4];` ` ` `// Function call` ` ` `document.write(seqLength(arr, K) + ` `'<br>'` `);` ` ` `// This code is contributed by Potta Lokesh` ` ` `</script>` |

**Output**

1

**Time Complexity:**** **O(N * K)**Auxiliary Space:**** **O(N * K)