【LeetCode每日练手】 组合总和1+组合总和2

39. 组合总和

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的数字可以无限制重复被选取。

说明：

所有数字（包括 target）都是正整数。
解集不能包含重复的组合。
示例 1：

 public static List<List<Integer>> combinationSum(int[] candidates, int target) {
        ArrayList<Integer> combina= new ArrayList<>();
        List<List<Integer>> ans = new ArrayList<>();
        Arrays.sort(candidates);
        combination(candidates,target,ans,combina,0);
        return ans;
    }

    private static void combination(int[] candidates, int target, List<List<Integer>> ans, ArrayList<Integer> combina, int idx) {
        if (idx==candidates.length)  return;
        if (target==0){
            ans.add(new ArrayList<>(combina));
            return;
        }
        // 直接跳过
        combination(candidates,target,ans,combina,idx+1);
        // 选择当前数
        if (target-candidates[idx]>=0){
            combina.add(candidates[idx]);
            combination(candidates,target-candidates[idx],ans,combina,idx);
            combina.remove(combina.size()-1);
        }
    }

40. 组合总和 II

给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用一次。

说明：

所有数字（包括目标数）都是正整数。
解集不能包含重复的组合。
示例 1:

优化和改进

因此，我们需要改进上述算法，在求出组合的过程中就进行去重的操作。我们可以考虑将相同的数放在一起进行处理，也就是说，如果数 x 出现了 y次，那么在递归时一次性地处理它们，即分别调用选择 0, 1,⋯,y 次 x 的递归函数。这样我们就不会得到重复的组合。具体地：

我们使用一个哈希映射（HashMap）统计数组candidates 中每个数出现的次数。在统计完成之后，我们将结果放入一个列表 freq 中，方便后续的递归使用。

列表freq 的长度即为数组candidates 中不同数的个数。其中的每一项对应着哈希映射中的一个键值对，即某个数以及它出现的次数。
在递归时，对于当前的第 pos 个数，它的值为 freq[pos][0]，出现的次数为 freq[pos][1]，那么我们可以调用

dfs(pos+1,rest−i×freq[pos][0])

即我们选择了这个数 i次。这里 i 不能大于这个数出现的次数，并且 i×freq[pos][0] 也不能大于 rest。同时，我们需要将 i 个freq[pos][0] 放入列表中。

这样一来，我们就可以不重复地枚举所有的组合了。

我们还可以进行什么优化（剪枝）呢？一种比较常用的优化方法是，我们将 freq 根据数从小到大排序，这样我们在递归时会先选择小的数，再选择大的数。这样做的好处是，当我们递归到 dfs(pos,rest) 时，如果 freq[pos][0] 已经大于 rest，那么后面还没有递归到的数也都大于 rest，这就说明不可能再选择若干个和为rest 的数放入列表了。此时，我们就可以直接回溯。

未改进的版本，机械判重

class Solution {
    public  List<List<Integer>> combinationSum2(int[] candidates, int target) {
        ArrayList<Integer> combina= new ArrayList<>();
        List<List<Integer>> ans = new ArrayList<>();
        Arrays.sort(candidates);
        combination(candidates,target,ans,combina,0);
        return ans;
    }
      public  void combination(int[] candidates, int target, List<List<Integer>> ans, ArrayList<Integer> combina, int idx) {
        if (target==0){
            for (List<Integer> an : ans) {
                int temp = 0;
                if(combina.size()==an.size()) for (int i = 0; i < combina.size(); i++) if (combina.get(i).equals(an.get(i))) temp++;
                if (temp==combina.size()) return;
            }
            ans.add(new ArrayList<>(combina));
            return;
        }
        if (idx==candidates.length)  return;
        // 直接跳过
        combination(candidates,target,ans,combina,idx+1);
        // 选择当前数
        if (target-candidates[idx]>=0){
            combina.add(candidates[idx]);
            combination(candidates,target-candidates[idx],ans,combina,idx+1);
            combina.remove(combina.size()-1);
        }
    }

}

改进之后的版本，3ms出结果

  public static List<List<Integer>> combinationSum(int[] candidates, int target) {
        ArrayList<Integer> combina= new ArrayList<>();
        List<List<Integer>> ans = new ArrayList<>();
        List<int[]> freq = new ArrayList<int[]>();
        Arrays.sort(candidates);
        for (int candidate : candidates)
            if (freq.isEmpty() || candidate!=freq.get(freq.size()-1)[0]){
                freq.add(new int[]{candidate,1});
            }else{
                ++freq.get(freq.size()-1)[1];
            }
        combination(target,ans,combina,freq,0);
        return ans;
    }

    private static void combination(int target, List<List<Integer>> ans, ArrayList<Integer> combina,List<int[]> freq, int idx) {
        if (target==0){ ans.add(new ArrayList<>(combina));return; }
        if (idx==freq.size() || target<freq.get(idx)[0])  return;
        // 直接跳过
        combination(target,ans,combina,freq,idx+1);
        // 选择当前数
        int most=Math.min(target/freq.get(idx)[0],freq.get(idx)[1]);
        for (int i = 1; i <= most; i++) {
            combina.add(freq.get(idx)[0]);
            combination( target - freq.get(idx)[0] * i, ans, combina, freq, idx + 1);
        }
        for (int i = 0; i < most; i++) {
            combina.remove(combina.size()-1);
        }
    }