回溯算法 组合问题

class Solution {
    
    
    private List<List<Integer>> ans = new ArrayList<>();
    public List<List<Integer>> combine(int n, int k) {
    
    
        getCombine(n, k, 1, new ArrayList<>());
        return ans;
    }
    
    public void getCombine(int n, int k, int start, List<Integer> list) {
    
    
        if(k == 0) {
    
    
            ans.add(new ArrayList<>(list));    //这里直接用list不行  直接add（list）输出全是[]
            return;
        }
        for(int i = start;i <= n - k + 1;i++) {
    
      //注意起点，每次循环，新的getCombine起点要从i开始，而不是start+1
            list.add(i);
            getCombine(n, k - 1, i+1, list);
            list.remove(list.size() - 1);  //为什么要删除呢？ 删除的目的是将本层加入的数据移除
        }
    }
}

class Solution {
    
    
    List<List<Integer>> ans = new ArrayList<>();
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
    
    
        Arrays.sort(candidates);
        List<Integer> a = new ArrayList<>();
        getsum(candidates,target,0,a);
        return ans;
    }
    public void getsum(int[] candidates, int target, int start, List<Integer> list){
    
    
        int len = candidates.length;
        if(target < 0){
    
    
            return ;
        }
        if(target == 0){
    
    
            ans.add(new ArrayList<>(list));    
        }
        for(int i=start; i<len; i++){
    
    
            if(i>start&&candidates[i]==candidates[i-1]){
    
        //这句话至关重要，去重操作
                continue;
            }
            list.add(candidates[i]);
            getsum(candidates,target-candidates[i],i+1,list);
            list.remove(list.size()-1);
        }
    }
}

动态规划思路  
状态转移方程：dp[i]= dp[i - nums[0]] + dp[i - nums[1]] + dp[i - nums[2]] + ... （当 [] 里面的数 >= 0）
public class Solution {
    
    

    /**
     * 这里状态定义就是题目要求的，并不难，状态转移方程要动点脑子，也不难：
     * 状态转移方程：dp[i]= dp[i - nums[0]] + dp[i - nums[1]] + dp[i - nums[2]] + ... （当 [] 里面的数 >= 0）
     * 特别注意：dp[0] = 1，表示，如果那个硬币的面值刚刚好等于需要凑出的价值，这个就成为 1 种组合方案
     * 再举一个具体的例子：nums=[1, 3, 4], target=7;
     * dp[7] = dp[6] + dp[4] + dp[3]
     * 即：7 的组合数可以由三部分组成，1 和 dp[6]，3 和 dp[4], 4 和dp[3];
     *
     * @param nums
     * @param target
     * @return
     */
    public int combinationSum4(int[] nums, int target) {
    
    
        int[] dp = new int[target + 1];
        // 这个值被其它状态参考，设置为 1 是合理的
        dp[0] = 1;

        for (int i = 1; i <= target; i++) {
    
    
            for (int num : nums) {
    
    
                if (num <= i) {
    
    
                    dp[i] += dp[i - num];
                }
            }
        }
        return dp[target];
    }
}