Leetcode - Combination Sum

My code:

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

public class Solution {
    public List> combinationSum(int[] candidates, int target) {
        ArrayList> result = new ArrayList>();
        if (candidates == null || candidates.length == 0)
            return result;
        ArrayList combination = new ArrayList();
        Arrays.sort(candidates);
        if (candidates[0] > target)
            return result;
        else if (candidates[0] == target) {
            combination.add(candidates[0]);
            result.add(combination);
            return result;
        }
        getCombination(0, 0, candidates, target, false, combination, result);
        return result;
    }
    
    private void getCombination(int begin, int sum, int[] candidates, int target, boolean isEqual,
                                ArrayList combination, ArrayList> result) {
        if (isEqual)
            result.add(new ArrayList(combination));
        else {
            for (int i = begin; i < candidates.length; i++) {
                int temp = sum + candidates[i];
                if (temp > target)
                    break;
                else if (temp == target) {
                    combination.add(candidates[i]);
                    getCombination(i, temp, candidates, target, true, combination, result);
                    combination.remove(combination.size() - 1);
                    break;
                }
                else {
                    combination.add(candidates[i]);
                    getCombination(i, temp, candidates, target, false, combination, result);
                    combination.remove(combination.size() - 1);
                }
            }
        }                   
    }
}

My test result:

Paste_Image.png

还是差不多的思路。
和老胡聊了下这类题目，其实就是DFS
用 for() 循环来罗列出所有情况，然后一个个递归。
同时，加入List的时候，得完全复制，不能简单地拷贝引用地址。
然后，可以用 boolean[] isVisited 来排除一些重复的情况。
差不多就是这样一个思路。然后每道题一定会有自己的特点的，再根据这些特点修改下细节。

**
总结： Array, DFS
**

Anyway, Good luck, Richardo!

My code:

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

扫了一眼老的代码，怎么那么复杂。。。
其实就是DFS.
记住了，少用布尔变量。

Anyway, Good luck, Richardo!