SubsetSum using recursion and backtracking - algorithm

Question

I have written an algorithm to return whether a subset of a group of numbers will sum to a given target using backtracking and recursion (returns true/false)
Ex: {5, 2, 3, 6} with Target = 8 ==> True ||
{5, 2, 3, 6} with Target = 20 ==> False
I want to modify my algorithm so that it includes all 5's that maybe present in the set. I am having a hard time how to figure this out using backtracking and recursion. Any advice is appreciated
Ex: {5, 2, 3, 6} with Target 8 ==>True ||
{6, 2, 3, 5, 5} with Target 8 ==> False
I have written an algorithm that recursively includes a number and checks the sum and then omits the number from the sum but I don't know how to modify my algorithm to only pick a certain numbers and include them in the sum
public static void main(String argv[]) {
int[] ints = { 10, 1, 3, 2 };
int target = 5;
int start = 0;
System.out.println(groupSum(ints, target, 0, start));
}
public static boolean groupSum(int[] arr, int target, int sum, int start) {
if (sum > target) {
return false;
}
if (sum == target) {
return true;
}
if (start >= arr.length) {
return false;
}
//choose
sum = sum + arr[start];
//explore
if (groupSum(arr, target, sum, start + 1))
return true;
//un-choose
sum = sum - arr[start];
return groupSum(arr, target, sum, start + 1);
}

Answer 1

Force it to only look at including 5 if it sees it, and only check = sum at the end. Like this:
public static void main(String argv[]) {
int[] ints = { 10, 1, 3, 2 };
int target = 5;
int start = 0;
System.out.println(groupSum(ints, target, 0, start));
}
public static boolean groupSum(int[] arr, int target, int sum, int start) {
if (sum > target) {
return false;
}
// NOTE: sum == target inside of end of array check so all 5s are found.
if (start >= arr.length) {
return sum == target;
}
//choose
sum = sum + arr[start];
//explore
if (groupSum(arr, target, sum, start + 1))
return true;
//un-choose
// NOTE: can't unchoose 5
if (5 == arr[start]) {
return false;
}
sum = sum - arr[start];
return groupSum(arr, target, sum, start + 1);
}
Update: Here is advice on how to solve problems like this.
Very clearly state what you want the function to do.
Very clearly state what the base case or cases are where you know the answer.
In the complex case, figure out how to reduce it to one or more simpler problems.
As long as you've done that, your recursive code should work. And if you're in doubt about how to modify, start over from scratch, only copying code from before where you've noticed that it can be left alone.
So for the first step, the statement is, We want groupSum to take an array arr of positive integers, a target target, a partial sum sum and an int start and to return whether it is possible to get the rest of the array to sum to target when you take a subset that has to include all 5s.
For the second step, base cases are:
We've already exceeded target, then it is false.
We've reached the end of the array and are at target, then it is true.
We've reached the end of the array and are blow target, then it is false. (I combined this with the last in the code by returning a comparison.)
For the third step, the reductions are as follows.
If we can add the current value and make it, the answer is true.
If the current value is not 5, we don't add it, and can make it, the answer is true.
Otherwise it is false.
I was trying to write the code in the way that looked most like what you already had. But to write it exactly according to this logic it would be like this:
public static boolean groupSumWithAll5s(int[] arr, int target, int sum, int start) {
// Base cases
if (sum > target) {
return false;
}
else if ((start >= arr.length) && (sum == target)) {
return true;
}
else if (start >= arr.length) {
return false;
}
// Recursive cases.
if (groupSumWithAll5s(arr, target, sum + arr[start], start + 1)) {
return true;
}
else if ((arr[start] != 5) && groupSumWithAll5s(arr, target, sum, start + 1)) {
return true;
}
else {
return false;
}
}