leetcode-39/40 Combination Sum / II

一、leetcode39 Combination Sum

问题描述：

Given a set of candidate numbers(C) and a target number (T), find all uniquecombinations in C where the candidate numbers sums to T.

The same repeatednumber may be chosen from C unlimited number of times.

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 2,3,6,7 and target 7, 
A solution set is: 
[7] 
[2, 2, 3] 

 

问题分析：

一个很明显的DFS（深度优先遍历）的问题，注意每个节点可以重复利用即可。

 

代码：

public class Solution39 {    /*** 简单的DFS算法***/    public List<List<Integer>> combinationSum(int[] candidates, int target) {       List<List<Integer>> result = new ArrayList<>();       if(candidates == null || candidates.length == 0)           return result;         //先对数组进行排序        Arrays.sort(candidates);        //每次遍历暂存节点数组        List<Integer> curr = new ArrayList<Integer>();         DFS_Search(candidates, target, 0 , curr, result);        return result;    }      /***     * @paramcandidates-- 源数据数组     * @paramtarget    -- 目标值     * @paramindex     -- 该循环数组起始位置     * @paramcurr      -- 暂存该次遍历中的所有节点     * @paramresult    -- 结果数组     ***/    private void DFS_Search(int[] candidates, int target, int index, List<Integer> curr, List<List<Integer>> result) {        //递归返回标志        if(target== 0){           List<Integer> temp = new ArrayList<Integer>(curr);           result.add(temp);           return;        } else{            for (int i = index; i < candidates.length; i++){                if(candidates[i] > target)                    return;                else {                    curr.add(candidates[i]);                    // 因为可以重复使用某个值，所以这里依然index使用i                    DFS_Search(candidates, target- candidates[i], i, curr, result);                    curr.remove(curr.size() - 1);               }           }        }    } }

二、leetcode-40 Combination Sum II

问题分析：

    与前面Combination Sum问题相比，其区别在于不能再重复利用同一个值；而且数组中可能出现值相同的元素。

    这里寻找匹配值同样还是应该用DFS算法，但与前面不同的是要注意考虑重复值的问题；

    消除重复值的策略是：如果前面路径中使用了某一元素，则下一相同值元素才可以使用（还要注意考虑如多个元素值相同的情况）。

    下面代码在Combination Sum基础上添加了一个用以记录上一个元素是否在路径中被使用的变量flag；在消除重复值时，仅需要判别flag即可。

 

代码：

public class Solution40 {    public List<List<Integer>> combinationSum2(int[] candidates, int target) {   List<List<Integer>> result = new ArrayList<>();       if(candidates == null || candidates.length == 0)           return result;       // 先对数组进行排序       Arrays.sort(candidates);       List<Integer> curr = new ArrayList<>();       DFS_Search2(candidates, target, 0 , curr, result, false);       return result;    }        /***     * @param candidates-- 源数据数组     * @param target    -- 目标值     * @param index     -- 该循环数组起始位置     * @param curr      -- 暂存该次遍历中的所有节点     * @param result    -- 结果数组     * @param flags     -- 用以标志前一个元素是否被使用     *      ***/    private void DFS_Search2(int[] candidates, int target, int index, List<Integer> curr, List<List<Integer>> result, boolean flags){        if(target == 0) {             result.add(new ArrayList(curr));            return;        } else {            for(int i = index; i < candidates.length; i++) {                // 处理有重复值情况                if((i >= 1) && candidates[i] == candidates[i - 1]) {                    if(!flags){                        continue;                    }                    }                if(candidates[i] > target)                     return;                curr.add(candidates[i]);                flags = true;                DFS_Search2(candidates, target - candidates[i], i + 1, curr, result, true);                curr.remove(curr.size() - 1);                flags = false;            }        }    }       public static void main(String[] args){        int[] data = {2, 2, 2};    int target = 4;    List<List<Integer>> results = new ArrayList<>();    results = new Solution40().combinationSum2(data, target);    System.out.println(results);    }}