LeetCode 题解（106）: Permutations

题目：

Given a collection of numbers, return all possible permutations.

For example,
[1,2,3] have the following permutations:
[1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], and [3,2,1].

题解：

典型的Backtracing or Depth First Search。要注意Java和Python的传引用与C++的不同。

C++版：

class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> results;
        if(nums.size() == 0)
            return results;
        vector<int> result;
        vector<bool> used(nums.size(), false);
        trace(results, result, used, nums);
        return results;
    }
    
    void trace(vector<vector<int>>& results, vector<int>& result, vector<bool>& used, vector<int>& nums) {
        if(result.size() == used.size()) {
            results.push_back(result);
            return;
        }
        for(int i = 0; i < nums.size(); i++) {
            if(!used[i]) {
                used[i] = true;
                result.push_back(nums[i]);
                trace(results, result, used, nums);
                result.pop_back();
                used[i] = false;
            }
        }
    }
};

Java版：

public class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> results = new ArrayList<List<Integer>>();
        if(nums.length == 0)
            return results;
        List<Integer> result = new ArrayList<>();
        boolean[] used = new boolean[nums.length];
        trace(results, result, used, nums);
        return results;
    }
    
    public void trace(List<List<Integer>> results, List<Integer> result, boolean[] used, int[] nums) {
        if(result.size() == nums.length) {
            List<Integer> local = new ArrayList<>();
            local.addAll(result);
            results.add(local);
            return;
        }
        for(int i = 0; i < nums.length; i++) {
            if(!used[i]) {
                used[i] = true;
                result.add(nums[i]);
                trace(results, result, used, nums);
                result.remove(result.size()-1);
                used[i] = false;
            }
        }
    }
}

Python版：

class Solution:
    # @param {integer[]} nums
    # @return {integer[][]}
    def permute(self, nums):
        if len(nums) == 0:
            return []
        used = [False for i in range(len(nums))]
        results = []
        result = []
        
        def trace(results, result, used, nums):
            if len(result) == len(nums):
                temp = result[:]
                results.append(temp)
                return
            for i in range(len(nums)):
                if not used[i]:
                    used[i] = True
                    result.append(nums[i])
                    trace(results, result, used, nums)
                    result.pop()
                    used[i] = False
                    
        trace(results, result, used, nums)
        return results