Create 39.组合总和(中等).md

JavaCodeMing · JavaCodeMing · commit 7c7c4cb7291d · 2020-08-23T23:01:24.000+08:00
diff --git a/Algorithm/39.组合总和(中等).md b/Algorithm/39.组合总和(中等).md
@@ -0,0 +1,54 @@
+```text
+��Ŀ: ����һ�����ظ�Ԫ�ص�����candidates��һ��Ŀ����target,�ҳ�candidates�����п���ʹ���ֺ�Ϊtarget�����;
+    candidates �е����ֿ����������ظ���ѡȡ;
+    ˵��:
+        ��������(���� target)����������;
+        �⼯���ܰ����ظ������;
+    ʾ�� 1:
+        ����:candidates=[2,3,6,7],target=7,����⼯Ϊ:
+        [
+          [7],
+          [2,2,3]
+        ]
+1.�ݹ���ݷ�:
+    [1]˼·: 
+        (1)ʹ�õݹ鷽ʽ,����Ҫ�ȿ��ǵݹ鷽������:
+            1)�����ĺ�ѡ����(candidates)��Ŀ����(target)�ز�����;
+            2)�������շ���Ƕ�׼���,��Ƕ�׽������Ҫ�����еݹ鷽���д���;
+            3)Ƕ�׽�������ڲ�������Ҫ�ڵݹ鷽���в���������,����ڲ������Ҳ��Ҫ;
+        (2)����ʹ�õ��ǵݹ�,��˵ݹ鷽����Ҫ���ǵݹ����ֹ����;
+        (3)�پ��ǿ���ʲô��������ӷ��������ļ��ϵ��������,ʲôʱ����Ҫ���еݹ����;
+        (4)�����ǻ��ݷ�,��Ҫ�ڱ����еݹ�,������������ʱ�ſɳ�����һ���ٵݹ����;
+    [2]ʵ��:
+        class Solution {
+            public static List<List<Integer>> combinationSum(int[] candidates, int target) {
+                List<List<Integer>> result = new ArrayList<>();
+                backtrack(candidates, result, target, new ArrayList<>(), 0);
+                return result;
+            }
+            // �ݹ����
+            private static void backtrack(int[] candidates, List<List<Integer>> result,
+                    int target, List<Integer> list, int start) {
+                // �ݹ����ֹ����
+                if (target < 0) {
+                    return;
+                }
+                // ��������ʱ,���ӵ��������
+                if (target == 0) {
+                    // ��listȫ�ֶ�һ��,���ӽ����ʱ��Ҫ��������
+                    result.add(new ArrayList<>(list));
+                } else {
+                    for (int i = start; i < candidates.length; i++) {
+                        list.add(candidates[i]);
+                        backtrack(candidates, result, target - candidates[i], list, i);
+                        // ����һ�㼶���ݵ��ò㼶,˵���ò㼶�����Ԫ�ز���������
+                        //(�������������Ӳ㼶�Ѿ����ӵ��������)
+                        list.remove(list.size() - 1);
+                    }
+                }
+            }
+        }
+    [3]���Ӷȷ���:
+        (1)ʱ�临�Ӷ�: O(N^H),NΪ���鳤��,HΪ���ݹ����
+        (2)�ռ临�Ӷ�: O(N)
+```

-Original file line number
+Diff line change
@@ @@ -0,0 +1,54 @@ @@
 +```text
 +题目: 给定一个无重复元素的数组candidates和一个目标数target,找出candidates中所有可以使数字和为target的组合;
 +    candidates 中的数字可以无限制重复被选取;
 +    说明:
 +        所有数字(包括 target)都是正整数;
 +        解集不能包含重复的组合;
 +    示例 1:
 +        输入:candidates=[2,3,6,7],target=7,所求解集为:
 +        [
 +          [7],
 +          [2,2,3]
 +        ]
 +1.递归回溯法:
 +    [1]思路:
 +        (1)使用递归方式,则需要先考虑递归方法参数:
 +            1)给定的候选数组(candidates)和目标数(target)必不可少;
 +            2)由于最终返回嵌套集合,则嵌套结果集需要在所有递归方法中传递;
 +            3)嵌套结果集的内部集合需要在递归方法中不断添加数,因此内部结果集也需要;
 +        (2)由于使用的是递归,因此递归方法中要考虑递归的终止条件;
 +        (3)再就是考虑什么情况下添加符合条件的集合到结果集中,什么时候需要进行递归操作;
 +        (4)由于是回溯法,需要在遍历中递归,当不满足条件时才可尝试下一个再递归测试;
 +    [2]实现:
 +        class Solution {
 +            public static List<List<Integer>> combinationSum(int[] candidates, int target) {
 +                List<List<Integer>> result = new ArrayList<>();
 +                backtrack(candidates, result, target, new ArrayList<>(), 0);
 +                return result;
 +            }
 +            // 递归回溯
 +            private static void backtrack(int[] candidates, List<List<Integer>> result,
 +                    int target, List<Integer> list, int start) {
 +                // 递归的终止条件
 +                if (target < 0) {
 +                    return;
 +                }
 +                // 符合条件时,添加到结果集中
 +                if (target == 0) {
 +                    // 该list全局独一份,添加结果集时需要拷贝添加
 +                    result.add(new ArrayList<>(list));
 +                } else {
 +                    for (int i = start; i < candidates.length; i++) {
 +                        list.add(candidates[i]);
 +                        backtrack(candidates, result, target - candidates[i], list, i);
 +                        // 由下一层级回溯到该层级,说明该层级加入的元素不符合条件
 +                        //(符合条件的在子层级已经添加到结果集了)
 +                        list.remove(list.size() - 1);
 +                    }
 +                }
 +            }
 +        }
 +    [3]复杂度分析:
 +        (1)时间复杂度: O(N^H),N为数组长度,H为最大递归深度
 +        (2)空间复杂度: O(N)
 +```