五刷46

Author: diguage

Diff for: docs/0000-21-decrease-and-conquer.adoc

@@ -14,3 +14,6 @@ D瓜哥最早知道减治法是在 https://book.douban.com/subject/26337727/[《
 * **减去的规模是可变的。**在减治法的减可变规模(variable-size-decrease)变化形式中，算法在每次迭代时，规模减小的模式都是不同的。
 ** 计算最大公约数的欧几里得算法是这种情况的一个很好的例子。 stem:[gcd(m, n)=gcd(n,m mod n)]
 
+== 参考资料
+
+. https://cloud.tencent.com/developer/article/1532598[【算法学习】减治 · 分治 · 变治^]

Diff for: docs/0000-25-subsets.adoc

@@ -1,18 +1,52 @@
 [#0000-25-subsets]
 = Subsets 子集
 
-一般都是使用多重DFS
+超级多的编程面试问题都会涉及到排列和组合问题。一般都是使用回溯来解决该类问题，回溯法属于 DFS 解法。子集问题模式讲的是用 BFS 来处理这些问题。
 
-超级多的编程面试问题都会涉及到排列和组合问题。子集问题模式讲的是用BFS来处理这些问题。
 
-这个模式是这样的：
+== 子集
 
-给一组数字 [1, 5, 3]
+举例来说明一下这个模式：
+
+给一组数字 `[1, 5, 3]`
+
+. 我们从空集开始：`[[]]`
+. 把第一个数 `1`，加到之前已经存在的集合中：`[[], [1]]`;
+. 把第二个数 `5`，加到之前的集合中得到：`[[], [1], [5], [1,5]]`;
+. 再加第三个数 `3`，则有：`[[], [1], [5], [1,5], [3], [1,3], [5,3], [1,5,3]]`.
+
+如果原有集合中存在重复元素，那么就需要针对这种情况特殊处理一下。流程如下：
+
+给一组数字 `[5, 1, 5]`
+
+. 先对原有集合进行排序： `[1, 5, 3]`
+. 从空集开始：`[[]]`
+. 把第一个数 `1`，加到之前已经存在的集合中：`[[], [1]]`;
+. 把第二个数 `5`，加到之前的集合中得到：`[[], [1], [5], [1,5]]`;
+. 处理第三个数，也是 `5` 时需要注意：
+.. 如果还是按照上述方案处理，那么就会得到如下结果： `[[], [1], [5], [1,5], *[5], [1, 5]*, [5, 5], [1,5, 5]]`。这里出现了重复子集： `[5], [1, 5]`。该方案不通过，❌
+.. 观察最后生成的所有子集与重复的子集，会发现重复的子集，在处理第二个数时，已经处理过 `[], [1]`，如果再次处理 `5`，那么就会出现重复。所以，只需要处理在处理上一个相同的数时新增加的子集即可。上一个相同数新增的子集是 `[5], [1,5]`，只需要在这些子集后面增加当前数字即可。这样最后的子集就是：`[[], [1], [5], [1,5], [5, 5], [1,5, 5]]`。方案通过 ✅
+
+== 排列
+
+举例来说明一下这个模式在处理排列问题时的步骤：
+
+给一组数字 `[1, 5, 3]`
+
+. 把第一个数 `1`，集合中：`[[1]]`;
+. 把第二个数 `5`，加到之前的集合中得到，由于 `[1, 5]` 和 `[5, 1]` 属于两个排列，那么就需要在所有可能的位置都增加一下，最后得到的排列如下：：`[[5, 1], [1,5]]`;
+. 再加第三个数 `3`，也是如上，在所有可能的位置都增加，最终排列如下：`[[3, 5, 1], [5, 3, 1],[5, 1, 3], [3, 1, 5], [1, 3, 5], [1, 5, 3]]`。
+
+思考一下：如何处理有重复元素的排列？
+
+// [1, 5, 5]
+//
+// `[[1]]`
+//
+// `[[5, 1], [1,5]]`
+//
+// `[[5, 5, 1], *[5, 5, 1]*,[5, 1, 5], *[5, 1, 5]*, [1, 5, 5], *[1, 5, 5]*]`
 
-. 我们从空集开始：[[]]
-. 把第一个数（1），加到之前已经存在的集合中：[[], [1]];
-. 把第二个数（5），加到之前的集合中得到：[[], [1], [5], [1,5]];
-. 再加第三个数（3），则有：[[], [1], [5], [1,5], [3], [1,3], [5,3], [1,5,3]].
 
 如果判断这种子集模式：
 

Diff for: docs/0046-permutations.adoc

@@ -66,14 +66,23 @@ include::{sourcedir}/_0046_Permutations_3.java[tag=answer]
 ----
 --
 
-四刷::
+四刷（回溯）::
 +
 --
 [{java_src_attr}]
 ----
 include::{sourcedir}/_0046_Permutations_4.java[tag=answer]
 ----
 --
+
+五刷（子集）::
++
+--
+[{java_src_attr}]
+----
+include::{sourcedir}/_0046_Permutations_5.java[tag=answer]
+----
+--
 ====
 
 == 参考资料

Diff for: logbook/202503.adoc

@@ -210,6 +210,11 @@ endif::[]
 |{doc_base_url}/0090-subsets-ii.adoc[题解]
 |⭕️ 子集，需要注意重复元素的处理。现在用 `Set` 记录已添加子集的方案还可以再优化。添加优化解法。
 
+|{counter:codes2503}
+|{leetcode_base_url}/permutations/[46. 全排列^]
+|{doc_base_url}/0046-permutations.adoc[题解]
+|✅ 子集。注意对比子集模式在处理子集和排列时的不同：①子集直接在结果中添加新子集；②排列则是将结果中的元素出队，添加新元素后，再入队。
+
 |===
 
 截止目前，本轮练习一共完成 {codes2503} 道题。

Diff for: src/main/java/com/diguage/algo/leetcode/_0046_Permutations_5.java

@@ -0,0 +1,39 @@
+package com.diguage.algo.leetcode;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+public class _0046_Permutations_5 {
+  // tag::answer[]
+  /**
+   * @author D瓜哥 · https://www.diguage.com
+   * @since 2025-04-10 17:22:39
+   */
+  public List<List<Integer>> permute(int[] nums) {
+    Queue<List<Integer>> result = new LinkedList<>();
+    result.offer(new ArrayList<>(List.of(nums[0])));
+    for (int i = 1; i < nums.length; i++) {
+      int num = nums[i];
+      int size = result.size();
+      for (int j = 0; j < size; j++) {
+        List<Integer> tmp = result.poll();
+        for (int k = 0; k <= tmp.size(); k++) {
+          List<Integer> adding = new ArrayList<>(tmp);
+          if (k == tmp.size()) {
+            adding.add(num);
+          } else {
+            adding.add(k, num);
+          }
+          result.offer(adding);
+        }
+      }
+    }
+    return new ArrayList<>(result);
+  }
+  // end::answer[]
+  public static void main(String[] args) {
+    new _0046_Permutations_5().permute(new int[]{1, 2, 3});
+  }
+}