add a solution for 46

Author: fishercoder1534

src/main/java/com/fishercoder/solutions/_46.java

@@ -1,7 +1,9 @@
 package com.fishercoder.solutions;
 
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 
 public class _46 {
 
@@ -29,4 +31,41 @@ private List<List<Integer>> backtracking(int[] nums, int index, List<List<Intege
         }
     }
 
+    public static class Solution2 {
+        /**
+         * My completely original solution on 10/11/2021, although a little verbose and super as efficient as the above one.
+         * Basically, insert the next unused number into all possible positions in the currently formed list,
+         * as soon as the size of this list equals nums.length, add this new permutation into the result;
+         * I'll have to use a HashSet to filter out duplicates.
+         */
+        public List<List<Integer>> permute(int[] nums) {
+            Set<List<Integer>> ans = new HashSet<>();
+            boolean[] used = new boolean[nums.length];
+            backtracking(new ArrayList<>(), nums, ans, used);
+            List<List<Integer>> result = new ArrayList<>();
+            for (List<Integer> list : ans) {
+                result.add(list);
+            }
+            return result;
+        }
+
+        private void backtracking(List<Integer> list, int[] nums, Set<List<Integer>> ans, boolean[] used) {
+            if (list.size() == nums.length) {
+                ans.add(new ArrayList<>(list));
+                return;
+            }
+            for (int i = 0; i <= list.size(); i++) {
+                for (int j = 0; j < nums.length; j++) {
+                    if (!used[j]) {
+                        used[j] = true;
+                        list.add(i, nums[j]);
+                        backtracking(list, nums, ans, used);
+                        used[j] = false;
+                        list.remove(i);
+                    }
+                }
+            }
+        }
+    }
+
 }

src/test/java/com/fishercoder/_46Test.java

@@ -7,19 +7,23 @@
 
 public class _46Test {
     private static _46.Solution1 solution1;
+    private static _46.Solution2 solution2;
 
     @BeforeClass
     public static void setup() {
         solution1 = new _46.Solution1();
+        solution2 = new _46.Solution2();
     }
 
     @Test
     public void test1() {
         CommonUtils.printListList(solution1.permute(new int[]{1, 2, 3}));
+        CommonUtils.printListList(solution2.permute(new int[]{1, 2, 3}));
     }
 
     @Test
     public void test2() {
         CommonUtils.printListList(solution1.permute(new int[]{1, 2, 3, 4, 5, 6}));
+        CommonUtils.printListList(solution2.permute(new int[]{1, 2, 3, 4, 5, 6}));
     }
 }