842.将数组拆分成斐波那契序列

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

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

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

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

返回从 num 拆分出来的任意一组斐波那契式的序列块，如果不能拆分则返回 []。
算法：
方法一.回溯算法
要返回bool判断是否需要回溯

func splitIntoFibonacci(num string) []int {
	ans := make([]int, 0)
	length := len(num)
	var backtrack func(index, ppre, pre int) bool 
	backtrack = func(index, ppre, pre int) bool {
                // 
		if index >= length {
			return len(ans) >= 3 
		}
		cur := 0
		for i := index; i < length; i ++ {
                        // 数字以0开头，但不是0
			if i > index && num[index] == '0' {
				break
			}

			cur = cur * 10 + int(num[i] - '0')
			if cur > math.MaxInt32 {
                break
            }
			if len(ans) >= 2 {
				if cur < ppre + pre {
					continue
				}
				if cur > ppre + pre {
					break
				}
			}
			ans = append(ans, cur)
                        // backtrack每次查找下一个fabonacci数，放入ans，并返回是否找到。
			if backtrack(i + 1,  pre, cur) {
				return true
			}
			ans = ans[:len(ans) - 1]
		}
		return false
	}
	backtrack(0, 0, 0)
	return ans
}

方法二：回溯算法
想到了要用回溯算法，又不那么确定，写不出来

func splitIntoFibonacci(num string) []int {
    ans := make([]int, 0)
    // max := 1 << 31
    var backtrack func(numChars []byte, index int) bool  
    backtrack = func(numChars []byte, index int) bool {
        if index == len(numChars) && len(ans) >= 3 {
            return true
        }
        for i := index; i < len(numChars); i ++ {
            number := subDigit(numChars, index,  i + 1)
            if numChars[index] == '0' && i > index {
                break
            }
            if number > math.MaxInt32 {
                break
            }
            n := len(ans)
            if n >= 2 && ans[n - 2] + ans[n - 1] < number {
                break
            }
            if n <= 1 || ans[n - 2] + ans[n - 1] == number {
                ans = append(ans, number)
                if backtrack(numChars, i + 1) {
                    return true
                }
                m := len(ans)
                ans = ans[:m - 1]
            }

        }
        return false
    }
    backtrack([]byte(num), 0)
    return ans
}



func subDigit(chars []byte, start, end int) int {
    ans := 0
    for i := start; i < end; i ++ {
        ans = ans * 10 + int(chars[i] - '0')
    }
    return ans
}