[Swift]LeetCode131. 分割回文串 | Palindrome Partitioning

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

Given a string s, partition s such that every substring of the partition is a palindrome.

Return all possible palindrome partitioning of s.

Example:

Input: "aab"
Output:
[
  ["aa","b"],
  ["a","a","b"]
]

---

给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。

返回 s 所有可能的分割方案。

示例:

输入: "aab"
输出:
[
  ["aa","b"],
  ["a","a","b"]
]

---

32ms

class Solution {
    func partition(_ s: String) -> [[String]] {
        var result = [[String]]()
        var candidate = [String]()
        
        backtracking(&result, &candidate, Array(s.characters), 0)
        
        return result
    }
    
    private func backtracking(_ result: inout [[String]], _ candidate: inout [String], _ characters: [Character], _ start: Int) {
        if start == characters.count {
            result.append(candidate)
        } else {
            for i in start..<characters.count {
                if isPalindrome(characters, start, i) {
                    let character = String(characters[start...i])
                    candidate.append(character)
                    backtracking(&result, &candidate, characters, i + 1)
                    candidate.removeLast()//clear every characters that fullfil requirement
                }
            }
        }
    }
    
    private func isPalindrome(_ characters: [Character], _ low: Int, _ high: Int) -> Bool {
        var low = low
        var high = high
        
        while low < high {
            if characters[low] != characters[high] {
                return false
            }
            low += 1
            high -= 1
        }
        
        return true
    }
}

---

80ms

class Solution {
    func isPartitionAfter(_ s:String, added:String) -> Bool {
    
    let newStr = added + s
    
    let tempStr = String(newStr.reversed())
    
    return newStr == tempStr
  }
  
        func partition(_ s: String) -> [[String]] {
    
    if s.isEmpty {
      
      return []
    }
    
    if s.count == 1 {
      
      return [[s]]
    }
    
    let first = String(s.first!)
    
    let startIndex = String.Index.init(encodedOffset: 1)
    
    let subs = partition(String(s[startIndex...]))
    
    var results:[[String]] = []
    
    for sub in subs {
      
      var temp = sub
      
      temp.insert(first, at: 0)
      
      results.append(temp)
      
      if isPartitionAfter(sub[0], added: first) {
        
        temp = sub
        
        temp[0] = first + sub[0]
        
        results.append(temp)
      }
      
      if sub.count > 1 {
        
        if !isPartitionAfter(sub[0], added: sub[1]) {
          
          if isPartitionAfter(sub[0] + sub[1], added: first) {
            
            temp = sub
            
            temp.removeFirst()
            
            temp[0] = first + sub[0] + sub[1]
            
            results.append(temp)
          }
        }
      }
    }
    
    return results
  }
}

---

656ms

class Solution {
    func partition(_ s: String) -> [[String]] {
        var paths = [[String]](), path = [String]()
        
        dfs(&paths, &path, Array(s), 0)
        
        return paths
    }
    
    fileprivate func dfs(_ paths: inout [[String]], _ path: inout [String], _ s: [Character], _ index: Int) {
        if index == s.count {
            paths.append(Array(path))
            return
        }
        
        for i in index..<s.count {
            let current = String(s[index...i])
            
            if current.isPalindrome {
                path.append(current)
                dfs(&paths, &path, s, i + 1)
                path.removeLast()
            }
        }
    }
}

extension String {
    var isPalindrome: Bool {
        let chars = Array(self)
        
        var i = 0, j = count - 1
        
        while i <= j {
            if chars[i] != chars[j] {
                return false
            }
            i += 1
            j -= 1
        }
        
        return true
    }
}

---

1040ms

class Solution {
    func partition(_ s: String) -> [[String]] {
        var result = [[String]]()
        helper([Character](s), [String](), &result)
        return result
    }
    
    func helper(_ chars: [Character], _ addedSub: [String], _ result: inout [[String]]) {
        if chars.count == 0 {
            return
        }
        if chars.count == 1 {
            var tempAddedSub = [String](addedSub)
            tempAddedSub.append(String(chars))
            result.append(tempAddedSub)
            return
        }
        
        let newStr = String(chars)
        
        if isPalindrome(newStr){
            var tempAddedSub = [String](addedSub)
            tempAddedSub.append(newStr)
            result.append(tempAddedSub)
        }
        
        for i in 1..<chars.count {
            
            let newPrefix = String(chars.prefix(upTo:i))
            let newSuffix = [Character](chars.suffix(from:i))
            if isPalindrome(newPrefix) {
                var tempAddedSub = [String](addedSub)
                tempAddedSub.append(newPrefix)
                helper([Character](newSuffix), tempAddedSub, &result)
            }
        }
    }
    
    func isPalindrome(_ s: String) -> Bool {
        return s == String(s.reversed())
    }
}