feat: update solutions to lc problems: No.46,1969 (#2466)

Author: acbin

solution/0000-0099/0046.Permutations/README.md

@@ -63,6 +63,28 @@ class Solution:
         return list(permutations(nums))
 ```
 
+```python
+class Solution:
+    def permute(self, nums: List[int]) -> List[List[int]]:
+        def dfs(i):
+            if i == n:
+                ans.append(t[:])
+                return
+            for j in range(n):
+                if not vis[j]:
+                    vis[j] = True
+                    t[i] = nums[j]
+                    dfs(i + 1)
+                    vis[j] = False
+
+        n = len(nums)
+        vis = [False] * n
+        t = [0] * n
+        ans = []
+        dfs(0)
+        return ans
+```
+
 ```java
 class Solution {
     private List<List<Integer>> ans = new ArrayList<>();
@@ -250,101 +272,4 @@ public class Solution {
 
 <!-- tabs:end -->
 
-### 方法二
-
-<!-- tabs:start -->
-
-```python
-class Solution:
-    def permute(self, nums: List[int]) -> List[List[int]]:
-        def dfs(i):
-            if i == n:
-                ans.append(t[:])
-                return
-            for j in range(n):
-                if not vis[j]:
-                    vis[j] = True
-                    t[i] = nums[j]
-                    dfs(i + 1)
-                    vis[j] = False
-
-        n = len(nums)
-        vis = [False] * n
-        t = [0] * n
-        ans = []
-        dfs(0)
-        return ans
-```
-
-```rust
-impl Solution {
-    #[allow(dead_code)]
-    pub fn permute(nums: Vec<i32>) -> Vec<Vec<i32>> {
-        let mut ret = Vec::new();
-        let mut cur_vec = Vec::new();
-        let mut vis = vec![false; nums.len() + 1];
-        Self::dfs(&nums, &mut vis, 0, &mut cur_vec, &mut ret);
-        ret
-    }
-
-    #[allow(dead_code)]
-    fn dfs(
-        nums: &Vec<i32>,
-        vis: &mut Vec<bool>,
-        index: i32,
-        cur_vec: &mut Vec<i32>,
-        ans: &mut Vec<Vec<i32>>
-    ) {
-        let n = nums.len();
-        if (index as usize) == n {
-            ans.push(cur_vec.clone());
-            return;
-        }
-        // Otherwise, let's iterate the nums vector
-        for i in 0..n {
-            if !vis[i] {
-                // If this number hasn't been visited, then visit it
-                vis[i] = true;
-                cur_vec.push(nums[i]);
-                Self::dfs(nums, vis, index + 1, cur_vec, ans);
-                // Reset the changes
-                cur_vec.pop().unwrap();
-                vis[i] = false;
-            }
-        }
-    }
-}
-```
-
-<!-- tabs:end -->
-
-### 方法三
-
-<!-- tabs:start -->
-
-```python
-class Solution:
-    def permute(self, nums: List[int]) -> List[List[int]]:
-        def dfs(i):
-            nonlocal mask
-            if i == n:
-                ans.append(t[:])
-                return
-            for j in range(n):
-                if (mask >> j & 1) == 0:
-                    mask |= 1 << j
-                    t[i] = nums[j]
-                    dfs(i + 1)
-                    mask ^= 1 << j
-
-        n = len(nums)
-        mask = 0
-        t = [0] * n
-        ans = []
-        dfs(0)
-        return ans
-```
-
-<!-- tabs:end -->
-
 <!-- end -->

solution/0000-0099/0046.Permutations/README_EN.md

@@ -235,101 +235,4 @@ public class Solution {
 
 <!-- tabs:end -->
 
-### Solution 2
-
-<!-- tabs:start -->
-
-```python
-class Solution:
-    def permute(self, nums: List[int]) -> List[List[int]]:
-        def dfs(i):
-            if i == n:
-                ans.append(t[:])
-                return
-            for j in range(n):
-                if not vis[j]:
-                    vis[j] = True
-                    t[i] = nums[j]
-                    dfs(i + 1)
-                    vis[j] = False
-
-        n = len(nums)
-        vis = [False] * n
-        t = [0] * n
-        ans = []
-        dfs(0)
-        return ans
-```
-
-```rust
-impl Solution {
-    #[allow(dead_code)]
-    pub fn permute(nums: Vec<i32>) -> Vec<Vec<i32>> {
-        let mut ret = Vec::new();
-        let mut cur_vec = Vec::new();
-        let mut vis = vec![false; nums.len() + 1];
-        Self::dfs(&nums, &mut vis, 0, &mut cur_vec, &mut ret);
-        ret
-    }
-
-    #[allow(dead_code)]
-    fn dfs(
-        nums: &Vec<i32>,
-        vis: &mut Vec<bool>,
-        index: i32,
-        cur_vec: &mut Vec<i32>,
-        ans: &mut Vec<Vec<i32>>
-    ) {
-        let n = nums.len();
-        if (index as usize) == n {
-            ans.push(cur_vec.clone());
-            return;
-        }
-        // Otherwise, let's iterate the nums vector
-        for i in 0..n {
-            if !vis[i] {
-                // If this number hasn't been visited, then visit it
-                vis[i] = true;
-                cur_vec.push(nums[i]);
-                Self::dfs(nums, vis, index + 1, cur_vec, ans);
-                // Reset the changes
-                cur_vec.pop().unwrap();
-                vis[i] = false;
-            }
-        }
-    }
-}
-```
-
-<!-- tabs:end -->
-
-### Solution 3
-
-<!-- tabs:start -->
-
-```python
-class Solution:
-    def permute(self, nums: List[int]) -> List[List[int]]:
-        def dfs(i):
-            nonlocal mask
-            if i == n:
-                ans.append(t[:])
-                return
-            for j in range(n):
-                if (mask >> j & 1) == 0:
-                    mask |= 1 << j
-                    t[i] = nums[j]
-                    dfs(i + 1)
-                    mask ^= 1 << j
-
-        n = len(nums)
-        mask = 0
-        t = [0] * n
-        ans = []
-        dfs(0)
-        return ans
-```
-
-<!-- tabs:end -->
-
 <!-- end -->

solution/0000-0099/0046.Permutations/Solution2.rs

@@ -61,7 +61,15 @@ The array product is 1 * 6 * 1 * 6 * 1 * 6 * 7 = 1512, which is the minimum poss
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Greedy + Fast Power
+
+We notice that each operation does not change the sum of the elements. When the sum of the elements remains unchanged, to minimize the product, we should maximize the difference between the elements as much as possible.
+
+Since the largest element is $2^p - 1$, no matter which element it exchanges with, it will not increase the difference. Therefore, we do not need to consider the case of exchanging with the largest element.
+
+For the other elements in $[1,..2^p-2]$, we pair the first and last elements one by one, that is, pair $x$ with $2^p-1-x$. After several operations, each pair of elements becomes $(1, 2^p-2)$. The final product is $(2^p-1) \times (2^p-2)^{2^{p-1}-1}$.
+
+The time complexity is $O(p)$, and the space complexity is $O(1)$.
 
 <!-- tabs:start -->