排列组合问题

Author: anduo

readme.md

@@ -255,7 +255,25 @@ doc中有好几份文档，比较经典，可以参考。
 - [question03 balanced binary tree](./src/ninechapter/ch03_binary_tree_and_divide_conquer_and_dfs_bfs/Question03BalancedBinaryTree.java)
 - [question04 binary tree maximum path sum](./src/ninechapter/ch03_binary_tree_and_divide_conquer_and_dfs_bfs/Question04BinaryTreeMaximumPathSum.java)
 
-
-
-
+## chapter04 permutation & subset
+
+排列组合问题总结
+- Arrays.sort 去重
+- result.add 什么时候输出结果
+- if(condition) continue 什么情况跳过
+- 回溯，关键是在递归完了，需要还原items的状态
+
+排列组合适用题目
+- word break ii
+- palindrome partition
+- path sum ii
+- restore ip address
+- subsets ii
+- subsets
+- combinations
+- permutations ii
+- permutation
+- combination sum ii
+- substring with concatenation of all words
+- letter combination of a phone number
 

src/ninechapter/ch04_permutation_and_subset/Question01SubSets.java

@@ -0,0 +1,53 @@
+package ninechapter.ch04_permutation_and_subset;
+// https://leetcode.com/problems/subsets/#/description
+// 子集
+// 给定一个含不同整数的集合，返回其所有的子集
+// http://www.lintcode.com/zh-cn/problem/subsets/
+// 如果 S = [1,2,3]，有如下的解：
+//[
+//    [3],
+//    [1],
+//    [2],
+//    [1,2,3],
+//    [1,3],
+//    [2,3],
+//    [1,2],
+//    []
+//]
+
+// 算法复杂度 2^n
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/**
+ * Created by anduo on 17-3-14.
+ */
+public class Question01SubSets {
+    public ArrayList<ArrayList<Integer>> subsets(int[] nums) {
+        ArrayList<ArrayList<Integer>> result = new ArrayList<>();
+        if (nums == null || nums.length == 0) {
+            return result;
+        }
+        Arrays.sort(nums);// 先排序是为了后边避免元素重复比如{1,2}和{2,1}
+
+        dfs(result, new ArrayList<>(), nums, 0);
+
+        return result;
+    }
+
+    private void dfs(ArrayList<ArrayList<Integer>> result,
+                     ArrayList<Integer> items,
+                     int[] nums,
+                     int pos) {
+        result.add(new ArrayList<>(items));
+
+        for (int i = pos; i < nums.length; i++) {
+            items.add(nums[i]);
+            dfs(result, items, nums, i + 1);
+            // *回溯* 移除最后添加一个元素，相当于返回上一层的集合
+            items.remove(items.size() - 1);
+        }
+    }
+
+}

src/ninechapter/ch04_permutation_and_subset/Question02SubSetsII.java

@@ -0,0 +1,54 @@
+package ninechapter.ch04_permutation_and_subset;
+// https://leetcode.com/problems/subsets/#/description
+// 子集
+// 给定一个含不同整数的集合，返回其所有的子集
+// http://www.lintcode.com/zh-cn/problem/subsets/
+// 如果 S = [1,2,3]，有如下的解：
+//[
+//    [3],
+//    [1],
+//    [2],
+//    [1,2,3],
+//    [1,3],
+//    [2,3],
+//    [1,2],
+//    []
+//]
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/**
+ * Created by anduo on 17-3-14.
+ */
+public class Question02SubSetsII {
+    public ArrayList<ArrayList<Integer>> subsets(int[] nums) {
+        ArrayList<ArrayList<Integer>> result = new ArrayList<>();
+        if (nums == null || nums.length == 0) {
+            return result;
+        }
+        Arrays.sort(nums);// 先排序是为了后边避免元素重复比如{1,2}和{2,1}
+
+        dfs(result, new ArrayList<>(), nums, 0);
+
+        return result;
+    }
+
+    private void dfs(ArrayList<ArrayList<Integer>> result,
+                     ArrayList<Integer> items,
+                     int[] nums,
+                     int pos) {
+        result.add(new ArrayList<>(items));
+
+        for (int i = pos; i < nums.length; i++) {
+            if (i > 0 && i != pos && nums[i] == nums[i - 1]) {
+                continue;
+            }
+            items.add(nums[i]);
+            dfs(result, items, nums, i + 1);
+            // *回溯* 移除最后添加一个元素，相当于返回上一层的集合
+            items.remove(items.size() - 1);
+        }
+    }
+
+}

src/ninechapter/ch04_permutation_and_subset/Question03Permutations.java

@@ -0,0 +1,37 @@
+package ninechapter.ch04_permutation_and_subset;
+
+import java.util.ArrayList;
+import java.util.List;
+
+// https://leetcode.com/problems/permutations/
+// 排列问题 时间复杂度 n!
+
+
+/**
+ * Created by anduo on 17-3-14.
+ */
+public class Question03Permutations {
+    public List<List<Integer>> permute(int[] nums) {
+        List<List<Integer>> result = new ArrayList<>();
+        dfs(result, new ArrayList<>(), nums);
+        return result;
+    }
+
+    private void dfs(List<List<Integer>> result,
+                     ArrayList<Integer> items,
+                     int[] nums) {
+        if (items.size() == nums.length) {
+            result.add(new ArrayList<>(items));
+        }
+
+        for (int i = 0; i < nums.length; i++) {
+            if (items.contains(nums[i])) {// 判断这个数是不是已经在排列中了
+                continue;
+            }
+            items.add(nums[i]);
+            dfs(result, items, nums);
+            items.remove(items.size() - 1);
+        }
+    }
+
+}

src/ninechapter/ch04_permutation_and_subset/Question03PermutationsII.java

@@ -0,0 +1,43 @@
+package ninechapter.ch04_permutation_and_subset;
+
+import java.util.ArrayList;
+import java.util.List;
+
+// https://leetcode.com/problems/permutations-ii/
+// 排列问题 时间复杂度 n!
+
+
+/**
+ * Created by anduo on 17-3-14.
+ */
+public class Question03PermutationsII {
+    public List<List<Integer>> permute(int[] nums) {
+        List<List<Integer>> result = new ArrayList<>();
+        boolean[] visited = new boolean[nums.length];
+
+        dfs(result, new ArrayList<>(), nums, visited);
+        return result;
+    }
+
+    private void dfs(List<List<Integer>> result,
+                     ArrayList<Integer> items,
+                     int[] nums, boolean[] visited) {
+        if (items.size() == nums.length) {
+            result.add(new ArrayList<>(items));
+        }
+
+        for (int i = 0; i < nums.length; i++) {
+            if (visited[i] ||
+                    i != 0 && nums[i] == nums[i - 1] && !visited[i - 1]) {
+                continue;
+            }
+            visited[i] = true;
+            items.add(nums[i]);
+            dfs(result, items, nums, visited);
+            // 回溯->递归之后还原
+            items.remove(items.size() - 1);
+            visited[i] = false;
+        }
+    }
+
+}

src/ninechapter/ch04_permutation_and_subset/Question04PermutationSequence.java

@@ -0,0 +1,27 @@
+package ninechapter.ch04_permutation_and_subset;
+
+// https://leetcode.com/problems/permutation-sequence
+// 第k个排列
+// 给定 n 和 k，求123..n组成的排列中的第 k 个排列。
+// 对于 n = 3, 所有的排列如下：
+// 123
+// 132
+// 213
+// 231
+// 312
+// 321
+// 如果 k = 4, 第4个排列为，231.
+
+/**
+ * Created by anduo on 17-3-14.
+ */
+public class Question04PermutationSequence {
+
+    public String getPermutation(int n, int k) {
+
+        return null;
+    }
+
+
+
+}

src/ninechapter/ch04_permutation_and_subset/Question05NQueens.java

@@ -0,0 +1,26 @@
+package ninechapter.ch04_permutation_and_subset;
+
+import java.util.ArrayList;
+
+// n皇后问题
+// n皇后问题是将n个皇后放置在n*n的棋盘上，皇后彼此之间不能相互攻击。
+// 给定一个整数n，返回所有不同的n皇后问题的解决方案。
+// 每个解决方案包含一个明确的n皇后放置布局，其中“Q”和“.”分别表示一个女王和一个空位置。
+
+/**
+ * Created by anduo on 17-3-14.
+ */
+public class Question05NQueens {
+    /**
+     * Get all distinct N-Queen solutions
+     * @param n: The number of queens
+     * @return: All distinct solutions
+     * For example, A string '...Q' shows a queen on forth position
+     */
+    ArrayList<ArrayList<String>> solveNQueens(int n) {
+        // write your code here
+        ArrayList<ArrayList<String>> result = new ArrayList<>();
+
+        return result;
+    }
+}