Combinations Related

Combinations

Given two integers n and k, return all possible combinations of k numbers out of 1 ... n.

For example,
If n = 4 and k = 2, a solution is:

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

This problem is a typical backtracking problem. Every time after getting a combination list and add it into the result list, remove the last element of the combination list and search for a new element. Use recursion through the levels.

                                                           

public class Solution {
    public List<List<Integer>> combine(int n, int k) {
         List<List<Integer>> ret = new ArrayList<List<Integer>>();
         List<Integer> list = new ArrayList<Integer>();
         helper(ret, list, n, k, 1);
         return ret;
    }
    
    private void helper(List<List<Integer>> ret, List<Integer> list, int n, int k, int position) {
        if (list.size() == k) {
            ret.add(new ArrayList<Integer>(list));
            return;
        }
        
        for (int i = position; i <= n; i++) {
            list.add(i);
            helper(ret,list,n,k,i+1);
            list.remove(list.size() - 1);
        }
    }
}

Combination Sum

Given a set of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.

The same repeated number may be chosen from C unlimited number of times.

Note:

• All numbers (including target) will be positive integers.
• Elements in a combination (a1, a2, … , ak) must be in non-descending order. (ie, a1 ≤ a2 ≤ … ≤ ak).
• The solution set must not contain duplicate combinations.

 

For example, given candidate set 2,3,6,7 and target 7, 
A solution set is: 
[7] 
[2, 2, 3] 

This problem is similar with the problem above. The target sum corresponds the number of elements in combination in the above problem.

public class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
       Arrays.sort(candidates);
       List<List<Integer>>  ret = new ArrayList<List<Integer>>();
       List<Integer> list = new ArrayList<Integer>();
       helper(ret, list, candidates, target, 0);
       
       return ret;
    }
    
    private void helper(List<List<Integer>> ret,List<Integer> list,int[] candidates,int target,int position) {
        if (target == 0) {
            ret.add(new ArrayList<Integer>(list));
            return;
        }
        
        for (int i = position; i < candidates.length && candidates[i] <= target; i++) {
            list.add(candidates[i]);
            helper(ret,list,candidates,target - candidates[i], i);
            list.remove(list.size() - 1);
        }
    }
    
    
    
}

Combination Sum 2

Given a collection of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.

Each number in C may only be used once in the combination.

Note:

• All numbers (including target) will be positive integers.
• Elements in a combination (a1, a2, … , ak) must be in non-descending order. (ie, a1 ≤ a2 ≤ … ≤ ak).
• The solution set must not contain duplicate combinations.

 

For example, given candidate set 10,1,2,7,6,1,5 and target 8, 
A solution set is: 
[1, 7] 
[1, 2, 5] 
[2, 6] 
[1, 1, 6] 

This problem is a little more difficult than the problem above. The list given contains duplicate numbers, so we need to add conditional judgement at the end of our loop to avoid duplicate combination list. In addition, all the elements in lists could only be used once.

For example, if the input candidate is 1,1,1 and the target is 2;

If we do not add any conditional judgement in the end, the result would be [[1,1],[1,1],[1,1]], so every time we remove the last element in the end, we need to judge whether the next element is duplicate or not. If it is duplicated, skip it.

public class Solution {
    public List<List<Integer>>  combinationSum2(int[] candidates, int target) {
       Arrays.sort(candidates);
       List<List<Integer>> ret = new ArrayList<List<Integer>>();
       List<Integer> list = new ArrayList<Integer>();
       helper(ret,list,candidates,target,0);
       return ret;
    }
    
    private void helper(List<List<Integer>> ret,List<Integer> list,int[] candidates,int target,int position) {
        if (target == 0) {
            ret.add(new ArrayList<Integer>(list));
            return;
        }
        
        if (target < 0) {
            return;
        }
        
        for (int i = position; i < candidates.length; i++) {
            list.add(candidates[i]);
            helper(ret, list, candidates, target - candidates[i], i + 1);
            list.remove(list.size() - 1);
            while(i < candidates.length - 1 && candidates[i] == candidates[i + 1]) i++;
        }
    }
    
   
    
}

Combination Sum 3

Find all possible combinations of k numbers that add up to a number n, given that only numbers from 1 to 9 can be used and each combination should be a unique set of numbers.

Ensure that numbers within the set are sorted in ascending order.

Example 1:

Input: k = 3, n = 7

Output:

 

[[1,2,4]]

 

Example 2:

Input: k = 3, n = 9

Output:

 

[[1,2,6], [1,3,5], [2,3,4]]

 

public class Solution {
    public List<List<Integer>> combinationSum3(int k, int n) {
        List<List<Integer>> ret = new ArrayList<List<Integer>>();
        List<Integer> list = new ArrayList<Integer>();
        helper(ret,list,k,n,1);
        return ret;
    }
    
    private void helper( List<List<Integer>> ret, List<Integer> list,int k,int n,int position) {
        if (n == 0 && k == 0) {
            ret.add(new ArrayList<Integer>(list));
            return;
        }
        
        if (n < 0 || k < 0)
            return;
        
        for (int i = position; i <= 9; i++) {
            list.add(i);
            helper(ret, list, k - 1, n - i, i + 1);
            list.remove(list.size() - 1);
        }
    }
}