My code:

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

public class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        ArrayList<List<Integer>> result = new ArrayList<List<Integer>>();
        if (candidates == null || candidates.length == 0)
            return result;
        ArrayList<Integer> combination = new ArrayList<Integer>();
        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<Integer> combination, ArrayList<List<Integer>> result) {
        if (isEqual)
            result.add(new ArrayList<Integer>(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() 循環(huán)來羅列出所有情況，然后一個個遞歸。
同時，加入List的時候，得完全復制，不能簡單地拷貝引用地址。
然后，可以用 boolean[] isVisited 來排除一些重復的情況。
差不多就是這樣一個思路。然后每道題一定會有自己的特點的，再根據這些特點修改下細節(jié)。

**
總結： Array, DFS
**

Anyway, Good luck, Richardo!

My code:

public class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        ArrayList<List<Integer>> ret = new ArrayList<List<Integer>>();
        if (candidates == null || candidates.length == 0 || target < 0)
            return ret;
        Arrays.sort(candidates);
        ArrayList<Integer> group = new ArrayList<Integer>();
        helper(0, candidates, 0, target, ret, group);
        return ret;
    }
    
    private void helper(int begin, int[] candidates, int sum, int target, 
                           ArrayList<List<Integer>> ret, ArrayList<Integer> group) {
        if (sum > target)
            return;
        else if (sum == target) {
            ret.add(new ArrayList<Integer>(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!