Update

problems/0046.全排列.md

@@ -211,44 +211,68 @@ class Solution {
 ```
 
 ### Python 
+**回溯**
 ```python 
 class Solution:
-    def permute(self, nums: List[int]) -> List[List[int]]:
-        res = []  #存放符合条件结果的集合
-        path = []  #用来存放符合条件的结果
-        used = []  #用来存放已经用过的数字
-        def backtrack(nums,used):
-            if len(path) == len(nums):
-                return res.append(path[:])  #此时说明找到了一组
-            for i in range(0,len(nums)):
-                if nums[i] in used:
-                    continue  #used里已经收录的元素，直接跳过
-                path.append(nums[i])
-                used.append(nums[i])
-                backtrack(nums,used)
-                used.pop()
-                path.pop()
-        backtrack(nums,used)
-        return res
-```
+    def __init__(self):
+        self.path = []
+        self.paths = []
 
-Python（优化，不用used数组）：
+    def permute(self, nums: List[int]) -> List[List[int]]:
+        '''
+        因为本题排列是有序的，这意味着同一层的元素可以重复使用，但同一树枝上不能重复使用(usage_list)
+        所以处理排列问题每层都需要从头搜索，故不再使用start_index
+        '''
+        usage_list = [False] * len(nums)
+        self.backtracking(nums, usage_list)
+        return self.paths
+
+    def backtracking(self, nums: List[int], usage_list: List[bool]) -> None:
+        # Base Case本题求叶子节点
+        if len(self.path) == len(nums):
+            self.paths.append(self.path[:])
+            return
+
+        # 单层递归逻辑
+        for i in range(0, len(nums)):  # 从头开始搜索
+            # 若遇到self.path里已收录的元素，跳过
+            if usage_list[i] == True:
+                continue
+            usage_list[i] = True
+            self.path.append(nums[i])
+            self.backtracking(nums, usage_list)     # 纵向传递使用信息，去重
+            self.path.pop()
+            usage_list[i] = False
+```
+**回溯+丢掉usage_list**
 ```python3
 class Solution:
+    def __init__(self):
+        self.path = []
+        self.paths = []
+
     def permute(self, nums: List[int]) -> List[List[int]]:
-        res = []  #存放符合条件结果的集合
-        path = []  #用来存放符合条件的结果
-        def backtrack(nums):
-            if len(path) == len(nums):
-                return res.append(path[:])  #此时说明找到了一组
-            for i in range(0,len(nums)):
-                if nums[i] in path:  #path里已经收录的元素，直接跳过
-                    continue
-                path.append(nums[i])
-                backtrack(nums)  #递归
-                path.pop()  #回溯
-        backtrack(nums)
-        return res
+        '''
+        因为本题排列是有序的，这意味着同一层的元素可以重复使用，但同一树枝上不能重复使用
+        所以处理排列问题每层都需要从头搜索，故不再使用start_index
+        '''
+        self.backtracking(nums)
+        return self.paths
+
+    def backtracking(self, nums: List[int]) -> None:
+        # Base Case本题求叶子节点
+        if len(self.path) == len(nums):
+            self.paths.append(self.path[:])
+            return
+
+        # 单层递归逻辑
+        for i in range(0, len(nums)):  # 从头开始搜索
+            # 若遇到self.path里已收录的元素，跳过
+            if nums[i] in self.path:
+                continue
+            self.path.append(nums[i])
+            self.backtracking(nums)
+            self.path.pop()
 ```
 
 ### Go 
@@ -309,6 +333,72 @@ var permute = function(nums) {
 
 ```
 
+C:
+```c
+int* path;
+int pathTop;
+int** ans;
+int ansTop;
+
+//将used中元素都设置为0
+void initialize(int* used, int usedLength) {
+    int i;
+    for(i = 0; i < usedLength; i++) {
+        used[i] = 0;
+    }
+}
+
+//将path中元素拷贝到ans中
+void copy() {
+    int* tempPath = (int*)malloc(sizeof(int) * pathTop);
+    int i;
+    for(i = 0; i < pathTop; i++) {
+        tempPath[i] = path[i];
+    }
+    ans[ansTop++] = tempPath;
+}
+
+void backTracking(int* nums, int numsSize, int* used) {
+    //若path中元素个数等于nums元素个数，将nums放入ans中
+    if(pathTop == numsSize) {
+        copy();
+        return;
+    }
+    int i;
+    for(i = 0; i < numsSize; i++) {
+        //若当前下标中元素已使用过，则跳过当前元素
+        if(used[i])
+            continue;
+        used[i] = 1;
+        path[pathTop++] = nums[i];
+        backTracking(nums, numsSize, used);
+        //回溯
+        pathTop--;
+        used[i] = 0;
+    }
+}
+
+int** permute(int* nums, int numsSize, int* returnSize, int** returnColumnSizes){
+    //初始化辅助变量
+    path = (int*)malloc(sizeof(int) * numsSize);
+    ans = (int**)malloc(sizeof(int*) * 1000);
+    int* used = (int*)malloc(sizeof(int) * numsSize);
+    //将used数组中元素都置0
+    initialize(used, numsSize);
+    ansTop = pathTop = 0;
+
+    backTracking(nums, numsSize, used);
+
+    //设置path和ans数组的长度
+    *returnSize = ansTop;
+    *returnColumnSizes = (int*)malloc(sizeof(int) * ansTop);
+    int i;
+    for(i = 0; i < ansTop; i++) {
+        (*returnColumnSizes)[i] = numsSize;
+    }
+    return ans;
+}
+```
 
 
 -----------------------