一天一道力扣题

46. 全排列

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例 1：

输入：nums = [1,2,3]

输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

示例 2：

输入：nums = [0,1]

输出：[[0,1],[1,0]]

示例 3：

输入：nums = [1]

输出：[[1]]

提示：

1 <= nums.length <= 6

-10 <= nums[i] <= 10

nums 中的所有整数 互不相同

来源：力扣（LeetCode）

链接：https://leetcode.cn/problems/permutations

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

典型的回溯算法。我们可以用递归去做这个题。

从某位开始一层一层向下递归，到头后重置状态返回顶部继续递归。

代码如下

    func dfs(_ nums: [Int], len: Int, depth: Int, path: [Int], used: [Bool], res: inout [[Int]]) {
        if depth == len {
            res.append(path)
            return
        }
        var newPath = path
        var newUsed = used
        for i in 0..<len {
            if newUsed[i] == false {
                newPath.append(nums[i])
                newUsed[i] = true
                dfs(nums, len: len, depth: depth + 1, path: newPath, used: newUsed, res: &res)
                newUsed[i] = false
                newPath.removeLast()
            }
        }
    }
    
    func permute(_ nums: [Int]) -> [[Int]] {
        var results:[[Int]] = []
        let len = nums.count
        let path:[Int] = []
        let used = Array(repeating: false, count: len)
        self.dfs(nums, len: len, depth: 0, path: path, used: used, res: &results)
        return results
    }

附结果

这种解法的事件复杂度比较高。

swift 有个函数是

public mutating func swapAt(_ i: Int, _ j: Int)

这个是O1复杂度，所以配合这个函数的话可以优化代码。

    var res = [[Int]]()
    var nums = [Int]()
    func permute(_ nums: [Int]) -> [[Int]] {
        self.nums = nums
        dfs(0)
        print("res:\(res)")
        return res
    }
    func dfs(_ idx:Int){
        if idx>=nums.count{
            res.append(nums)
            return
        }
        for i in idx..<nums.count{
            if idx == i {
                dfs(idx+1)
                continue
            }
            print("idx:\(idx), i:\(i)")
            print("before: \(nums)")
            nums.swapAt(idx,i)
            print("after: \(nums)")
            dfs(idx+1)
            nums.swapAt(idx,i)
        }
    }

附结果。

PS: 不要把print放到执行代码块里... 十分影响执行用时