查找具有给定总和的数字子集

Question

Using recursion, write a program that given a list of integer numbers and a given sum, will find all the subsets of the numbers whose total is that given sum. Count the number of subsets found. If no subset exists, you should indicate that no solution is found. For example, given the list 6, 13, 3, 3 and the sum is 19, your program should find two solutions:

6 + 13 = 19
13 + 3 + 3 = 19

Limit the number of integers in the input list to a maximum of 20 integers. Accept positive integers only and use 0 to mark the end of list. The following is a sample run:

Enter positive integers terminated with 0: 6 13 3 3 0
Enter the desired sum: 19
Solution 1:6 +13 =19
Solution 2: 13 +3 +3 =19
Found 2 solutions

this is my code,but it is only finding one sub set, i want to find all sub sets. any help?

 public static boolean SubSetSum(int start, int[] nums, int target) {
        if (start >= nums.length) {
            return (target == 0);
        }
        if (SubSetSum(start + 1, nums, target - nums[start])) {

            System.out.println( nums[start] );
            return true;
        }
        if (SubSetSum(start + 1, nums, target)) {

            return true;
        }
        return false;

    }




    public static void main(String[] args) {

        int[] mySet = {4,1,3,2};
        int sum = 5;
        System.out.println("The Goal is : " + sum);

       SubSetSum(0,mySet, sum) ;
    }
}

Answer 1

Your main issues are that you:

• are returning right away once you find the solution
• are only considering numbers from left to right for your solution

What you need to do is consider all possible sublists of the original list for your solution eg, for a list of [A, B, C, D] , the solution may be [A, C, D] . So a good place to start is some code that is able to create all sublists of a list. To do this you will need to have a Set of Lists where you can aggregate all possibilities. Here is an example that does this by removing elements from a copy of the original list, but there are many ways to do this:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

class ResursionTest {
    public static void findSubsets(Set<List<Integer>> allSubsets, List<Integer> nums) {
        if (nums.size() == 0) {
            return;
        }

        // add the current list as a possibility
        allSubsets.add(new ArrayList<>(nums));

        // then add a possibility that has one less
        for (int i = 0; i < nums.size(); i++) {
            final List<Integer> subset = new ArrayList<>(nums);
            subset.remove(i);
            findSubsets(allSubsets, subset);
        }
    }


    public static void main(String[] args) {
        final Integer[] array = {4, 1, 3, 2};
        final HashSet<List<Integer>> allSubsets = new HashSet<>();

        findSubsets(allSubsets, Arrays.asList(array));
        System.out.println(allSubsets);
    }
}

If you run this, you will see by the output that we are finding all the sublists of the original input list [4, 1, 3, 2] .

Output check:

[[3, 2], [1], [4, 3], [2], [3], [1, 2], [4, 3, 2], [1, 3], [4], [4, 1, 2], [4, 1, 3], [4, 1, 3, 2], [4, 1], [1, 3, 2], [4, 2]]

Then all that is left is to only add sublists that add up to the requested number, instead of adding all possibilities.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

class ResursionTest {
    public static void findSubsets(Set<List<Integer>> allSubsets, List<Integer> nums, int sum) {
        if (nums.size() == 0) {
            return;
        }

        int currentSum = 0;
        for (Integer num : nums) {
            currentSum += num;
        }

        // does the current list add up to the needed sum?
        if (currentSum == sum) {
            allSubsets.add(new ArrayList<>(nums));
        }

        for (int i = 0; i < nums.size(); i++) {
            final List<Integer> subset = new ArrayList<>(nums);
            subset.remove(i);
            findSubsets(allSubsets, subset, sum);
        }
    }


    public static void main(String[] args) {
        int sum = 5;
        final Integer[] array = {4, 1, 3, 2};
        final HashSet<List<Integer>> allSubsets = new HashSet<>();

        findSubsets(allSubsets, Arrays.asList(array), sum);
        System.out.println(allSubsets);
    }
}

Answer check:

[[3, 2], [4, 1]]

There are some optimizations you can still make with this code that I will leave up to you.

Answer 2

The basic problem is that you've returned the wrong information: you need all of the solutions found, but you've returned only a boolean according to whether you succeeded. Instead, you need to construct a list of solutions.

Base cases:

• if target = 0, you succeeded. Print the solution and increment the counter.
• else if target < 0, you failed.
• else if you have no items left, you failed.

Recursion cases:

You did okay on the basic idea: recur both with and without subtracting the current number. However, you could also pass down a list of the numbers used in this branch -- that way, when you hit the bottom, you can print the list. There are other ways to handle this step, but I think this is simplest for your application. If you're not allowed to change the signature of SubSetSum, then use that as a "wrapper" and call your real function from there, starting with an empty list.

Does this get you moving? You could also check the dozens of previous questions about this problem.

Answer 3

My Dp Solution :-

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while(t-->0){
            int n = sc.nextInt();
        int arr[] = new int[n];
        for(int i = 0;i<n;i++){
            arr[i] = sc.nextInt();
        }
        int target = sc.nextInt();
        int dp[] = new int[target+1];
        dp[0] = 1;
        int currSum = 0;
        for(int i = 0;i<n;i++){
            currSum += arr[i];
            for(int j =  Math.min(currSum,target);j>= arr[i];j--){
                dp[j] += dp[j-arr[i]];
            }
        }
        System.out.println(dp[target]);
        }
    }

Time coplx. O(N*target) space complx. O(N)