package com.thealgorithms.dynamicprogramming;

/**
 * Find the number of subsets present in the given array with a sum equal to target.
 * Based on Solution discussed on StackOverflow(https://stackoverflow.com/questions/22891076/count-number-of-subsets-with-sum-equal-to-k)
 * @author Samrat Podder(https://github.com/samratpodder)
 */
public class SubsetCount {


    /**
     * Dynamic Programming Implementation.
     * Method to find out the number of subsets present in the given array with a sum equal to target.
     * Time Complexity is O(n*target) and Space Complexity is O(n*target)
     * @param arr is the input array on which subsets are  to searched
     * @param target is the sum of each element of the subset taken together
     *
     */
    public int getCount(int[] arr, int target){
        /**
         * Base Cases - If target becomes zero, we have reached the required sum for the subset
         * If we reach the end of the array arr then, either if target==arr[end], then we add one to the final count
         * Otherwise we add 0 to the final count
         */
        int n = arr.length;
        int[][] dp = new int[n][target+1];
        for (int i = 0; i < n; i++) {
            dp[i][0] = 1;
        }
        if(arr[0]<=target) dp[0][arr[0]] = 1;
        for(int t=1;t<=target;t++){
            for (int idx = 1; idx < n; idx++) {
                int notpick = dp[idx-1][t];
                int pick =0;
                if(arr[idx]<=t) pick+=dp[idx-1][target-t];
                dp[idx][target] = pick+notpick;
            }
        }
        return dp[n-1][target];
    }


    /**
     * This Method is a Space Optimized version of the getCount(int[], int) method and solves the same problem
     * This approach is a bit better in terms of Space Used
     * Time Complexity is O(n*target) and Space Complexity is O(target)
     * @param arr is the input array on which subsets are  to searched
     * @param target is the sum of each element of the subset taken together
     */
    public int getCountSO(int[] arr, int target){
        int n = arr.length;
        int[] prev =new int[target+1];
        prev[0] =1;
        if(arr[0]<=target) prev[arr[0]] = 1;
        for(int ind = 1; ind<n; ind++){
            int[] cur =new int[target+1];
            cur[0]=1;
            for(int t= 1; t<=target; t++){
                int notTaken = prev[t];
                int taken = 0;
                if(arr[ind]<=t) taken = prev[t-arr[ind]];
                cur[t]= notTaken + taken;
            }
            prev = cur;
        }
        return prev[target];
    }

}