Python递归问题【leetcode问题】

Question

Above is the question. It is to find all the permutation in for given array of integers(all unqiue)

Actual Question

I was trying out check the brute-force method permutation method( Not looking for the optimal solution ). I found myself in this peculiar problem. The result array used to store the permutations changed with every recursion call. I cannot put a head around it why is that. Need help figuring it out.

I have included print() from different places of the code for debugging purpose. Let me know if you need any other information to help you reach an answer.

Algorithm walkthrough

element_map -> stores False for each position of the input array [False,False,False] in this case temp_result -> stores temporary permutations in each step

1. permutation function iterates over every val of the input array and stores permutations in the temp_result array.
2. Once an element is added to temp_result , it marks element_map as True and recursively calls permutation function again.
3. End of recursion is if len(temp_result) == len(nums) . In that case, we got one permutation and we add it to result.
4. Once base case 3 is hit we set element_map[i] = False and pop the last val from temp_result

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        
        if len(nums) == 1:
            return [nums]
        
        result = []
        element_map = defaultdict(bool)
        for i in range(len(nums)):
            element_map[i] = False
        
        def permutations(nums, temp_result, element_map):
            nonlocal result
            print("Start result ->", result)
            print("Start temp_result ->", temp_result)
            
            if len(temp_result) == len(nums):
                result.append(temp_result)
                print(len(temp_result),len(nums))
                print("temp_result ->", temp_result)
                print("result-> ",result)
                return
            
            for i,val in enumerate(nums):
                
                if not element_map[i]:
                    element_map[i] = True
                    temp_result.append(val)
                    permutations(nums, temp_result, element_map)
                    temp_result.pop()
                    element_map[i] = False
        
        temp_result = []
        permutations(nums, temp_result, element_map)
        print(result)

Code Output for input [1,2,3]. Issue is the result keeps changing.

Start result -> []
Start temp_result -> []
Start result -> []
Start temp_result -> [1]
Start result -> []
Start temp_result -> [1, 2]
Start result -> []
Start temp_result -> [1, 2, 3]
3 3
temp_result -> [1, 2, 3]
result->  [[1, 2, 3]]
Start result -> [[1, 3]]
Start temp_result -> [1, 3]
Start result -> [[1, 3, 2]]
Start temp_result -> [1, 3, 2]
3 3
temp_result -> [1, 3, 2]
result->  [[1, 3, 2], [1, 3, 2]]
Start result -> [[2], [2]]
Start temp_result -> [2]
Start result -> [[2, 1], [2, 1]]
Start temp_result -> [2, 1]
Start result -> [[2, 1, 3], [2, 1, 3]]
Start temp_result -> [2, 1, 3]
3 3
temp_result -> [2, 1, 3]
result->  [[2, 1, 3], [2, 1, 3], [2, 1, 3]]
Start result -> [[2, 3], [2, 3], [2, 3]]
Start temp_result -> [2, 3]
Start result -> [[2, 3, 1], [2, 3, 1], [2, 3, 1]]
Start temp_result -> [2, 3, 1]
3 3
temp_result -> [2, 3, 1]
result->  [[2, 3, 1], [2, 3, 1], [2, 3, 1], [2, 3, 1]]
Start result -> [[3], [3], [3], [3]]
Start temp_result -> [3]
Start result -> [[3, 1], [3, 1], [3, 1], [3, 1]]
Start temp_result -> [3, 1]
Start result -> [[3, 1, 2], [3, 1, 2], [3, 1, 2], [3, 1, 2]]
Start temp_result -> [3, 1, 2]
3 3
temp_result -> [3, 1, 2]
result->  [[3, 1, 2], [3, 1, 2], [3, 1, 2], [3, 1, 2], [3, 1, 2]]
Start result -> [[3, 2], [3, 2], [3, 2], [3, 2], [3, 2]]
Start temp_result -> [3, 2]
Start result -> [[3, 2, 1], [3, 2, 1], [3, 2, 1], [3, 2, 1], [3, 2, 1]]
Start temp_result -> [3, 2, 1]
3 3
temp_result -> [3, 2, 1]
result->  [[3, 2, 1], [3, 2, 1], [3, 2, 1], [3, 2, 1], [3, 2, 1], [3, 2, 1]]
[[],[],[],[],[],[]]

Answer 1

I've written an alternative to your function. I've tested this with Python2, but it should work with Python3 as well.

Arr = [1, 2, 3, 4, 5]

def permute(arr):
    myresult = []
    for i in range(len(arr)):
        sarr = arr[:i] + arr[i+1:]
        el = arr[i]
        if len(sarr) != 0:
            a = permute(sarr)
            for result in a:
                c = [el] + result
                myresult.append(c)
        else:
            return [[el]]
    return myresult

p = permute(Arr)
print str(p)

myresult is going to be the result of the permute function. sarr stands for the "smaller array". el stands for Element (of the Array).

The idea is to pick an element and to concatenate each permutation of the remaining array. By using recursion the entire input array will be processed

Answer 2

Found the solution

if len(temp_result) == len(nums):
     result.append(temp_result[:])

instead of

if len(temp_result) == len(nums):
     result.append(temp_result)

In the latter result values changes with the value of temp_result .