Leetcode-Combinations Sum II

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 (a₁, a₂, … , a_k) must be in non-descending order. (ie, a₁ ≤ a₂ ≤ … ≤ a_k).
• 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]

Have you met this question in a real interview?

 

Analysis:

Since there are duplicates, for each value, we get the number of elements that are this value. We sort the array, at each step in the recursion, we try to use 0 to elementNumOfCurValue number of this value. For next step, we directly skip to the next value.

 

Solution:

 public class Solution {
     public List<List<Integer>> combinationSum2(int[] num, int target) {
         int[] candidates = num;
         List<List<Integer>> resSet = new ArrayList<List<Integer>>();
         List<Integer> curRes = new ArrayList<Integer>();
         if (candidates.length==0) return resSet;
         Arrays.sort(candidates);
         int cur=0,end=candidates.length-1;
         for (int i=0;i<candidates.length;i++)
             if (candidates[i]>target){
                 end = i-1;
                 break;
             }

         sumRecur(candidates,cur,end,target,resSet,curRes);

         return resSet;

     }

     public void sumRecur(int[] candidates, int cur, int end, int valLeft, List<List<Integer>> resSet, List<Integer> curRes){
         if (valLeft==0){
             List<Integer> temp = new ArrayList<Integer>();
             temp.addAll(curRes);
             resSet.add(temp);
             return;
         }

         if (cur>end) return;

         int newLeft = valLeft;
         int curLen = curRes.size();
         int nextIndex = cur;
         while (nextIndex<=end && candidates[nextIndex]==candidates[cur]) nextIndex++;

         for (int i=cur;i<nextIndex;i++)
             if (newLeft>=candidates[i]){
                 curRes.add(candidates[i]);
                 newLeft -= candidates[i];
                 sumRecur(candidates,nextIndex,end,newLeft,resSet,curRes);
             } else
                 break;

         while (curRes.size()!=curLen) curRes.remove(curRes.size()-1);

         sumRecur(candidates,nextIndex,end,valLeft,resSet,curRes);
     }
 }