Shortest Subsequence with sum exactly K

// 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
        // for 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.

using System;
using System.Collections.Generic;

public class GFG {

    // Function to calculate the required length of subsequence
    static int seqLength(List<int> arr, int k)
    {
        int n = arr.Count;

        // Initialize the DP table
        List<List<int>> dp = new List<List<int>>();
        for (int i = 0; i <= n; i++) {
            dp.Add(new List<int>());
            for (int j = 0; j <= k; j++) {
                dp[i].Add(1000000000);
            }
        }

        // Base case: If the sum is 0, we need 0 elements
        for (int i = 0; i <= n; i++) {
            dp[i][0] = 0;
        }

        // Fill the DP table iteratively
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= k; j++) {

                // If the current element is greater than the current sum
                if (arr[i - 1] > j) {
                    dp[i][j] = dp[i - 1][j];
                }

                // If the current element is less than or equal to the current sum
                else {

                    // Take the minimum of the two cases:
                    // 1. Include the current element
                    // 2. Exclude the current element
                    dp[i][j] = Math.Min(dp[i - 1][j - arr[i - 1]] + 1, dp[i - 1][j]);
                }
            }
        }

        // Check if the result is greater than or equal to 1e9
        return (dp[n][k] >= 1000000000) ? -1 : dp[n][k];
    }

    // Driver Code
    public static void Main()
    {
        int K = 4;
        List<int> arr = new List<int>() { 1, 2, 2, 3, 4 };

        // Function call
        Console.WriteLine(seqLength(arr, K));
    }
}