[Swift]LeetCode842. 将数组拆分成斐波那契序列 | Split Array into Fibonacci Sequence

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

Given a string S of digits, such as S = "123456579", we can split it into a Fibonacci-like sequence [123, 456, 579].

Formally, a Fibonacci-like sequence is a list F of non-negative integers such that:

• 0 <= F[i] <= 2^31 - 1, (that is, each integer fits a 32-bit signed integer type);
• F.length >= 3;
• and F[i] + F[i+1] = F[i+2] for all 0 <= i < F.length - 2.

Also, note that when splitting the string into pieces, each piece must not have extra leading zeroes, except if the piece is the number 0 itself.

Return any Fibonacci-like sequence split from S, or return [] if it cannot be done.

Example 1:

Input: "123456579"
Output: [123,456,579]

Example 2:

Input: "11235813"
Output: [1,1,2,3,5,8,13]

Example 3:

Input: "112358130"
Output: []
Explanation: The task is impossible.

Example 4:

Input: "0123"
Output: []
Explanation: Leading zeroes are not allowed, so "01", "2", "3" is not valid.

Example 5:

Input: "1101111"
Output: [110, 1, 111]
Explanation: The output [11, 0, 11, 11] would also be accepted.

Note:

1. 1 <= S.length <= 200
2. S contains only digits.

---

给定一个数字字符串 S，比如 S = "123456579"，我们可以将它分成斐波那契式的序列 [123, 456, 579]。

形式上，斐波那契式序列是一个非负整数列表 F，且满足：

• 0 <= F[i] <= 2^31 - 1，（也就是说，每个整数都符合 32 位有符号整数类型）；
• F.length >= 3；
• 对于所有的0 <= i < F.length - 2，都有 F[i] + F[i+1] = F[i+2]成立。

另外，请注意，将字符串拆分成小块时，每个块的数字一定不要以零开头，除非这个块是数字 0 本身。

返回从 S 拆分出来的所有斐波那契式的序列块，如果不能拆分则返回 []。

示例 1：

输入："123456579"
输出：[123,456,579]

示例 2：

输入: "11235813"
输出: [1,1,2,3,5,8,13]

示例 3：

输入: "112358130"
输出: []
解释: 这项任务无法完成。

示例 4：

输入："0123"
输出：[]
解释：每个块的数字不能以零开头，因此 "01"，"2"，"3" 不是有效答案。

示例 5：

输入: "1101111"
输出: [110, 1, 111]
解释: 输出 [11,0,11,11] 也同样被接受。

提示：

1. 1 <= S.length <= 200
2. 字符串 S 中只含有数字。

---

8ms

class Solution {
    fileprivate var res = [Int]()
    fileprivate var maxVal = Int(pow(2.0,31.0)-1)
    fileprivate var found = false
    
    func splitIntoFibonacci(_ S: String) -> [Int] {
        guard S.count >= 3 else {
            return [Int]()
        }
        
        var S = S.characters.map{Int(String($0))!}
        
        findSequence(S)
        return found ? res : [Int]()
    }
    
    func findSequence(_ S: [Int], _ from: Int = 0){
        if from >= S.count && res.count >= 3{
            found = true
            return
        }
    
        var current = 0
        for i in from..<S.count{
            current *= 10
            current += S[i]
            guard current < maxVal else{
                return
            }
            
            if i - from >= 1 && current < 10{
                return
            }
            
            if isFibSeq(current){
                findSequence(S, i + 1)
                if found{
                    return
                }
                res.remove(at: res.count - 1)
            }
        }
    }
    
    func isFibSeq(_ num: Int)->Bool{
        let count = res.count
        if count < 2{
            res.append(num)
            return true
        }
        
        if res[count - 1] + res[count - 2] == num{
            res.append(num)
            return true
        }
        
        return false
    }
}

---

20ms

private extension String {
    var leadingZero: Bool {
        guard self.count > 1 else {
            return false
        }

        if self[self.startIndex] == "0" {
            return true
        }

        return false
    }
}

/// 我们将一个给定的字符串进行分割，分割成斐波那契数列

class Solution {
    var limit: Int = 2_147_483_647

    func splitIntoFibonacci(_ S: String) -> [Int] {
        if S.count < 3 {
            return []
        }
        var array: [String] = []

        for index in 1...(min(10, S.count - 2)) {
            let firstString = String(S.prefix(index))

            let lastString = String(S.suffix(S.count - index))

            array.append(firstString)

            if firstString.leadingZero {
                return []
            }

            if findSecondSecondString(String(lastString), list: &array) {
                return array.map({Int($0) ?? 0})
            } else {
                array.removeAll()
            }
        }

        return []
    }

    func findSecondSecondString(_ S: String, list: inout [String]) -> Bool {
        if S.count  < 1 {
            return false
        }

        for index in 1...(min(10, S.count - 1)) {
            let firstString = String(S.prefix(index))

            let lastString = String(S.suffix(S.count - index))

            list.append(firstString)

            if judgeStringCanUse(lastString, list: &list) {
                return true
            } else {
                let keep = list[0]
                list.removeAll()
                list.append(keep)
                continue
            }
        }
        return false
    }

    func judgeStringCanUse(_ S: String, list: inout [String]) -> Bool {
        if S.count == 0 && list.count > 2 {
            return true
        }

        let n = Int(list[list.count - 1]) ?? 0
        let n1 = Int(list[list.count - 2]) ?? 0
        let target = n + n1
        guard n <= limit && n1 <= limit && target <= limit else {
            return false
        }

        let targetString = "(n + n1)"

        let firstS = S.prefix(targetString.count)

        if firstS == targetString {
            list.append(String(firstS))

            return judgeStringCanUse(String(S.suffix(S.count - firstS.count)), list: &list)
        }

        return false
    }
}

---

Runtime: 36 ms

Memory Usage: 21.8 MB

class Solution {
    func splitIntoFibonacci(_ S: String) -> [Int] {
        var ans:[Int] = [Int]()
        var cur:[Int] = [Int]()
        if S.isEmpty {return ans}
        SFhelper(S,0,&cur,&ans)
        return ans
    }
    
    func SFhelper(_ S:String,_ start:Int,_ cur:inout [Int],_ ans:inout [Int])
    {
        if !ans.isEmpty{return}
        if start == S.count
        {
            if cur.count > 2 { ans += cur}
            return
        }
        let N:Int = cur.count
        var V:Int64 = 0
        var arrS:[Character] = Array(S)
        for i in start..<S.count
        {
            V = V * 10  +  Int64((arrS[i].ascii - 48))
            if V > 2147483647 {break}
            if N < 2
            {
                cur.append(Int(V))
                SFhelper(S, i + 1, &cur, &ans)
                cur.popLast()
            }
            else
            {
                let beforeSum:Int = cur[N - 1] + cur[N - 2]
                if beforeSum > V {continue}
                else if beforeSum < V {break}
                else
                {
                    cur.append(Int(V))
                    SFhelper(S, i + 1, &cur, &ans)
                    cur.popLast()
                }
            }
             if V==0 {break}
        }
    }
}

//Character扩展
extension Character
{
    //Character转ASCII整数值(定义小写为整数值)
    var ascii: Int {
        get {
            return Int(self.unicodeScalars.first?.value ?? 0)
        }
    }
}

---

100ms

class Solution {
    private var result: [Int] = []
    func splitIntoFibonacci(_ S: String) -> [Int] {
        split(Array(S), nil, nil, nil, 0, [])
        return result
    }
    
    private func split(_ s: [Character],
                       _ op1: Int?,
                       _ op2: Int?,
                       _ sum: Int?,
                       _ start: Int,
                       _ out: [Int]) -> Bool {
        if start == s.count {
            if op1 != nil && op2 != nil && sum != nil {
                result = out
                return true 
            }
            return false 
        } else {
            for i in start..<s.count {
                 if i - start > 0 && s[start] == "0" { return false }
                if let num = String(s[start...i]).toInt() {
                    if num > Int(pow(2.0, 31.0)) - 1 { return false }
                    if op1 == nil {
                        if split(s, num, op2, sum, i + 1, out + [num]) {
                            return true 
                        }
                    } else if op2 == nil {
                        if split(s, op1, num, sum, i + 1, out + [num]) {
                            return true 
                        }
                    } else {
                        if num - op1! == op2! {
                            if split(s, op2, num, num, i + 1, out + [num]) {
                                return true 
                            }
                        }
                    }
                }
            }
              return false
        }
    }
}

extension String {
    func toInt() -> Int? {
        return Int(self)!
    }
}

---

104ms

class Solution {
    func splitIntoFibonacci(_ S: String) -> [Int] {
        var result = [Int]()
        var chars = Array(S)
        helper(&result, chars)
        return result
    }
    
    fileprivate func helper(_ res: inout [Int], _ chars: [Character]) -> Bool {
        if res.count > 2 && chars.count == 0 {
            return true
        }
        
        for i in 0..<chars.count {
            if chars[0] == "0" && i > 0 {
                break
            }
            
            // Int("2147483647214748364")!
            
            guard let val = Int(String(chars[0...i])), val < Int32.max else {
                return false
            }
            
            
            let size = res.count
            if size >= 2 && val > res[size - 1] + res[size - 2] {
                return false
            }

            if size < 2 || val == res[size - 1] + res[size - 2] {
                res.append(val)
                if helper(&res, Array(chars[(i+1)...])) {
                    return true
                }
                res.removeLast()
            }
        }
        return false;
    }
}