[Swift]LeetCode46. 全排列 | Permutations

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9907570.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Given a collection of distinct integers, return all possible permutations.

Example:

Input: [1,2,3]
Output:
[
  [1,2,3],
  [1,3,2],
  [2,1,3],
  [2,3,1],
  [3,1,2],
  [3,2,1]
]

---

给定一个没有重复数字的序列，返回其所有可能的全排列。

示例:

输入: [1,2,3]
输出:
[
  [1,2,3],
  [1,3,2],
  [2,1,3],
  [2,3,1],
  [3,1,2],
  [3,2,1]
]

---

 12ms

class Solution {
  func permute (_ arr:[Int]) -> [[Int]] {
    
    var array = arr
    var result = [[Int]]()
    helper(&array,0,&result)
    return result
}

func helper (_ arr: inout [Int], _ begin:Int, _ results: inout [[Int]]){
    
    if begin >= arr.count{
        results.append(arr)
        return
    } else {
        for i in begin..<arr.count{
            // choose
            arr.swapAt(begin, i)
            // explore
            helper(&arr, begin + 1, &results)
            // unchoose
            arr.swapAt(begin, i)
        }
    }
  }
｝

---

16ms

class Solution {
    func permute(_ nums: [Int]) -> [[Int]] {
        
        var result = [[Int]]()
        var temp = [Int]()
        
        var isVisited : [Bool] = Array(repeating: false, count: nums.count)
        backTracking(nums, &result, &temp, &isVisited)
        return result
        
    }
    
    func backTracking(_ nums: [Int], _ result: inout [[Int]], _ temp: inout [Int], _ isVisited: inout [Bool]) {
        if temp.count == nums.count {
            result.append(temp)
            return
        }
        for i in 0 ..< nums.count where !isVisited[i] {
            temp.append(nums[i])
            isVisited[i] = true
            backTracking(nums, &result, &temp, &isVisited)
            isVisited[i] = false
            temp.removeLast()
        }
    }
}

---

24ms

class Solution {
    func permute(_ nums: [Int]) -> [[Int]] {
    var result = [[Int]]()
    var nums = nums
    
    func permute(nums: inout [Int], start: Int, end: Int) {
        if start == end {
            result.append(nums)
        } else {
            for i in start...end {
                nums.swapAt(i, start)
                permute(nums: &nums, start: start + 1, end: end)
                nums.swapAt(i, start)
            }
        }
    }
    permute(nums: &nums, start: 0, end: nums.count - 1)
    return result
    }
}

---

36ms

class Solution {
    func permute(_ nums: [Int]) -> [[Int]] {
        var result : [[Int]] = []
        permuteNext(from: nums, to: [], result: &result)
        return result
    }
    func permuteNext(from : [Int] , to : [Int]  , result : inout [[Int]]) {
        if from.count == 0 {
            result.append(to)
            return
        }
        
        for idx in 0..<from.count {
            var newfrom = from
            newfrom.remove(at: idx)
            permuteNext(from: newfrom, to: to + [from[idx]], result: &result)
        }
    }
}

---

36ms

class Solution {
    var collectList: [[Int]] = []
      func permute(_ nums: [Int]) -> [[Int]] {
        
        if(nums.count == 0) {
            return collectList
        }
        
        permuteDFS(nums, start: 0, tempList: [Int]())
        
        return collectList
    }
    
     func permuteDFS(_ nums: [Int], start: Int, tempList: [Int]) {
        
        var temp = tempList
        
        if(temp.count == nums.count) {
            
            collectList.append(temp)
            
        }else {
            
            for i in 0 ..< nums.count {
                
                if( temp.contains(nums[i])) {
                    continue
                }
                
                temp.append(nums[i])
                
                permuteDFS(nums, start: (i + 1), tempList: temp)
                
                temp.removeLast()
            }
            
        }
        
    }
    
}

---

60ms

class Solution {
    func permute(_ nums: [Int]) -> [[Int]] {
       if nums.isEmpty {
            return[[]]
        } else if nums.count == 1 {
            return [nums]
        } else {
            var result = [[Int]]()
            for i in 0..<nums.count {
                var nums = nums
                let num = nums.remove(at: i)
                for j in permute(nums) {
                    result.append([num] + j)
                }
            }
            return result
        }
    }
}

---

80ms

class Solution {
    func permute(_ nums: [Int]) -> [[Int]] {
        var result: [[Int]] = []
        permute(nums, [], &result)
        return result
    }
    
    func permute(_ nums: [Int], _ nums2: [Int], _ result: inout [[Int]]) {
        guard nums2.count != nums.count else {
            result.append(nums2)
            return
        }
        
        nums.filter { !nums2.contains($0) }.forEach { (num) in
            var nums4 = nums2
            nums4.append(num)
            permute(nums, nums4, &result)
        }
    }
}