Count of subsets with sum equal to target

// A C++ program to count the number of subsets with a
// sum equal to a target using recursion and memoization
#include <bits/stdc++.h>
using namespace std;

// Function to recursively count subsets with a given sum
// using memoization to avoid redundant calculations
int countSubsets(int i, int currentSum, int target, 
                 vector<int> &arr, vector<vector<int>> &memo) {

    // Get the size of the array
    int n = arr.size();

    // Base case: If we've processed all elements in the array
    if (i == n)
      
        // Return 1 if the current subset's 
        // sum equals the target, else return 0
        return (currentSum == target);

    // Check if the result for the current state is already computed
    if (memo[i][currentSum] != -1)
        return memo[i][currentSum];

    // Case 1: Exclude the current element and 
  	// move to the next
    int exclude = countSubsets(i + 1, currentSum, target, arr, memo);

    // Case 2: Include the current element in the subset
    int include = 0;

    // Only include the current element if 
    // adding it does not exceed the target sum
    if ((arr[i] + currentSum) <= target)
        include = countSubsets(i + 1, currentSum + arr[i], target, arr, memo);

    // Store the result in the memoization table 
  	// and return it
    return memo[i][currentSum] = (include + exclude);
}

// Function to initiate the recursive subset count with memoization
// Parameters:
// - arr: Input array of integers
// - target: Target sum for the subsets
int perfectSum(vector<int> &arr, int target) {

    // Get the size of the array
    int n = arr.size();

    // Initialize a 2D memoization table with -1
    // Rows represent indices in the array
    // Columns represent possible sums up to the target
    vector<vector<int>> memo(n + 1, vector<int>(target + 1, -1));

    // Start the recursion from the first element with 
  	// a current sum of 0
    return countSubsets(0, 0, target, arr, memo);
}

int main() {
  
    vector<int> arr = {1, 2, 3, 3};
    int target = 6;
    cout << perfectSum(arr, target);

    return 0;
}

// A C++ program to count the number of subsets with a
// sum equal to a target using tabular dp
#include <bits/stdc++.h>
using namespace std;

int perfectSum(vector<int> &arr, int target) {

    // Get the size of the input array
    int n = arr.size();

    // Create a 2D DP table with dimensions (n+1) x (target+1)
    // dp[i][j] represents the number of ways to achieve a sum 'j'
    // using the first 'i' elements of the array
    vector<vector<int>> dp(n + 1, vector<int>(target + 1, 0));

    // Base case: There's exactly one way to achieve a
    // sum of 0 (by selecting no elements)
    dp[0][0] = 1;

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

        for (int j = 0; j <= target; j++) {

            // First, consider excluding the current element
            dp[i][j] = dp[i - 1][j];

            // Then, consider including the current element
            // (if the remaining sum allows it)
            if (j >= arr[i - 1]) {
                dp[i][j] += dp[i - 1][j - arr[i - 1]];
            }
        }
    }

    // Return the number of ways to achieve the
    // target sum using all elements in the array
    return dp[n][target];
}

int main() {
    vector<int> arr = {1, 2, 3, 3};
    int target = 6;
    cout << perfectSum(arr, target);

    return 0;
}

// A C++ program to count the number of subsets with a
// sum equal to a target using space-optimized tabular DP

#include <bits/stdc++.h>
using namespace std;

// Function to calculate the number of subsets with a given sum
// Parameters:
// - arr: Input array of integers
// - target: Target sum for the subsets
int perfectSum(vector<int> &arr, int target) {

    int n = arr.size();

    // Create two 1D DP arrays: `prev` for the previous state
    // and `curr` for the current state
    vector<int> prev(target + 1, 0), curr(target + 1, 0);

    // Base case: There's one way to achieve a sum
    // of 0 (by selecting no elements)
    prev[0] = 1;

    // Iterate through the elements of the array
    for (int i = 1; i <= n; i++) {

        // Start by copying the previous state
        // to the current state
        curr = prev;

        // Update the current DP array for sums up to the target
        for (int j = 0; j <= target; j++) {

            // If the current element can be included in the subset
            if (j >= arr[i - 1]) {
                curr[j] += prev[j - arr[i - 1]];
            }
        }

        // Move to the next state by updating 
      	// `prev` to `curr`
        prev = curr;
    }

    // Return the number of ways to
  	// achieve the target sum
    return curr[target];
}

int main() {
    vector<int> arr = {1, 2, 3, 3};
    int target = 6;
    cout << perfectSum(arr, target);

    return 0;
}