技術標籤：leetcode列表字串資料結構

題目

給定一個數字字串 S，比如 S = "123456579"，我們可以將它分成斐波那契式的序列 [123, 456, 579]。

形式上，斐波那契式序列是一個非負整數列表 F，且滿足：

• ，（也就是說，每個整數都符合 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 <= S.length<= 200
• 字串 S 中只含有數字。

解題思路

方法一：回溯 + 剪枝

將給定的字串拆分成斐波那契式序列，可以通過回溯的方法實現。

使用列表儲存拆分出的數，回溯過程中維護該列表的元素，列表初始為空。遍歷字串的所有可能的字首，作為當前被拆分出的數，然後對剩餘部分繼續拆分，直到整個字串拆分完畢。

根據斐波那契式序列的要求，從第 3 個數開始，每個數都等於前 2 個數的和，因此從第 3 個數開始，需要判斷拆分出的數是否等於前 2 個數的和，只有滿足要求時才進行拆分，否則不進行拆分。

回溯過程中，還有三處可以進行剪枝操作。

• 拆分出的數如果不是 0，則不能以 0 開頭，因此如果字串剩下的部分以 0開頭，就不需要考慮拆分出長度大於 1 的數，因為長度大於 1 的數以 0 開頭是不符合要求的，不可能繼續拆分得到斐波那契式序列；
• 拆分出的數必須符合 32 位有符號整數型別，即每個數必須在的範圍內，如果拆分出的數大於 ，則不符合要求，長度更大的數的數值也一定更大，一定也大於 ，因此不可能繼續拆分得到斐波那契式序列；
• 如果列表中至少有 2 個數，並且拆分出的數已經大於最後 2個數的和，就不需要繼續嘗試拆分了。

當整個字串拆分完畢時，如果列表中至少有 3 個數，則得到一個符合要求的斐波那契式序列，返回列表。如果沒有找到符合要求的斐波那契式序列，則返回空列表。

實現方面，回溯需要帶返回值，表示是否存在符合要求的斐波那契式序列。

C++

class Solution {
public:
    vector<int> splitIntoFibonacci(string S) {
        vector<int> list;
        backtrack(list, S, S.length(), 0, 0, 0);
        return list;
    }

    bool backtrack(vector<int>& list, string S, int length, int index, long long sum, int prev) {
        if (index == length) {
            return list.size() >= 3;
        }
        long long curr = 0;
        for (int i = index; i < length; i++) {
            if (i > index && S[index] == '0') {
                break;
            }
            curr = curr * 10 + S[i] - '0';
            if (curr > INT_MAX) {
                break;
            }
            if (list.size() >= 2) {
                if (curr < sum) {
                    continue;
                }
                else if (curr > sum) {
                    break;
                }
            }
            list.push_back(curr);
            if (backtrack(list, S, length, i + 1, prev + curr, curr)) {
                return true;
            }
            list.pop_back();
        }
        return false;
    }
};

Python

class Solution:
    def splitIntoFibonacci(self, S: str) -> List[int]:
        ans = list()

        def backtrack(index: int):
            if index == len(S):
                return len(ans) >= 3
            
            curr = 0
            for i in range(index, len(S)):
                if i > index and S[index] == "0":
                    break
                curr = curr * 10 + ord(S[i]) - ord("0")
                if curr > 2**31 - 1:
                    break
                
                if len(ans) < 2 or curr == ans[-2] + ans[-1]:
                    ans.append(curr)
                    if backtrack(i + 1):
                        return True
                    ans.pop()
                elif len(ans) > 2 and curr > ans[-2] + ans[-1]:
                    break
        
            return False
        
        backtrack(0)
        return ans

複雜度分析

• 時間複雜度：，其中 n 是字串的長度，C 是題目規定的整數範圍 。在回溯的過程中，實際上真正進行「回溯」的只有前 2 個數，而從第 3 個數開始，整個斐波那契數列是可以被唯一確定的，整個回溯過程只起到驗證（而不是列舉）的作用。對於前 2 個數，它們的位數不能超過 ，那麼列舉的空間為 ；對於後面的所有數，回溯的過程是沒有「分支」的，因此時間複雜度為 O(n)，相乘即可得到總時間複雜度 。
• 空間複雜度：O(n)，其中 n是字串的長度。除了返回值以外，空間複雜度主要取決於回溯過程中的遞迴呼叫層數，最大為 n。