264、将数组拆分成斐波那契数序列（示例代码的学习）

题目描述：
给定一个数字字符串 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 <= S.length <= 200
字符串 S 中只含有数字。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/split-array-into-fibonacci-sequence
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
和263
累加数
是差不多的，但是这道题需要的是将所有的情况给放在list中，使用long类型也溢出，然后只能考虑使用字符串进行，bug调试了好长时间，全部改成了使用字符串进行操作，繁琐，而且要细心

import java.math.BigInteger;
import java.util.*;
import java.util.Map.Entry;
class Solution {
   public List<Integer> splitIntoFibonacci(String S) {
        List<Integer> list = new ArrayList<>();
        int len = S.length();
        if (S.length() <= 2) {
            return list;
        }
        for (int i = 1; i < len - 1; i++) {
            if (i >= S.length() || (i >= 2 && S.charAt(0) == '0')) {
                return  new ArrayList<>();
            }
            String pre = S.substring(0, i);
            if(dayu(pre)){
                return new ArrayList<>();
            }
            for (int j = 1; j < len - 1; j++) {
                list = new ArrayList<>();
                pre = S.substring(0, i);
                if(dayu(pre) ){
                    break;
                }
                list.add(Integer.valueOf(pre));
                if (i + j >= S.length() || len - (i + j) < Math.max(i, j) || (j >= 2 && S.charAt(i) == '0')) {
                    break;
                }
                String last = S.substring(i, i + j);
                int cur = i + j;
                String tem = add(pre , last);
                boolean is = true;
                if(dayu(last)){
                    break;
                }
                list.add(Integer.valueOf(last));
                while (cur < S.length() && S.substring(cur).indexOf(tem) == 0) {
                    is = false;
                    if (S.substring(cur).startsWith("0") && tem.length() > 1) {
                        break;
                    }
                    cur += tem.length();
                    pre = last;
                    last = tem;
                    list.add(Integer.valueOf(tem));
                    tem = add(last,pre); 
                    // System.out.println(tem);
        
                    if(dayu(tem)){
                        break;
                    }
                    }
                if (cur == S.length() && !is) {
//                    return true;
                    return  list;
                }
            }
        }
//        return false;

        return new ArrayList<>();
    }
    public boolean dayu(String num){
        BigInteger max = new BigInteger(String.valueOf(Integer.MAX_VALUE));
        BigInteger max2 = new BigInteger(num);
        if(max.max(max2).equals(max)){
            return false;
        }
        return true;
    }
       public static String add(String num1, String num2) {
       int len1 = num1.length() - 1;
        int len2 = num2.length() - 1;
        int carry = 0;
        int k = Math.max(len1, len2);
        int sum[] = new int[k + 1];
        while (len1 >= 0 || len2 >= 0) {
            int temp1 = len1 >= 0 ? (num1.charAt(len1) - '0') : 0;
            int temp2 = len2 >= 0 ? (num2.charAt(len2) - '0') : 0;
            int temp = temp1 + temp2 + carry;
            sum[k] = temp % 10;
            carry = temp / 10;
            k--;
            len1--;
            len2--;
        }
        StringBuilder s = new StringBuilder();
        if (carry != 0)
            s.append(carry);
        int i = 0;
        for (; i < sum.length; i++) {
            s.append(sum[i]);
        }
        i = 0;
        for (; i < s.length(); i++) {
            if(s.charAt(i) != '0'){
                break;
            }
        }
        if(i == s.length()){
            return "0";
        }
        return s.substring(i).toString();
    }
}

真的又臭又长

原来可以这样转成long查看是否大于int类型啊

class Solution {
    public List<Integer> splitIntoFibonacci(String S) {
        ArrayList<Integer> ans = new ArrayList();
        int len = S.length();
        for (int i = 1; i <= len / 2; i++) {
            if (S.charAt(0) == '0' && i > 1) break;
            long tmp1 = Long.parseLong(S.substring(0, i));
            if (tmp1 > Integer.MAX_VALUE) break;
            ans.add((int)tmp1);
            for (int j = 1; Math.max(i, j) <= len - i - j; j++) {
                if (S.charAt(i) == '0' && j > 1) break;
                long tmp2 = Long.parseLong(S.substring(i, i + j));
                if (tmp2 > Integer.MAX_VALUE) break;
                int num1 = (int)tmp1;
                int num2 = (int)tmp2;
                ans.add(num2);
                String sum;
                int start;
                for (start = i + j; start < len; start += sum.length()) {
                    num2 = num1 + num2;
                    num1 = num2 - num1;
                    sum = String.valueOf(num2);
                    if (!S.startsWith(sum, start)) {
                        break;
                    }
                    ans.add(num2);
                }
                if (len == start) return ans;
                for (int idx = ans.size() - 1; idx >= 1; idx--) ans.remove(idx);
            }
            ans.remove(0);
        }
        
        return ans;
    }
}

再看看回溯法

class Solution {
    public List<Integer> splitIntoFibonacci(String S) {
        List res = new ArrayList<>();
        helper(S, res, 0);
        return res;
    }

    private boolean helper(String s, List<Integer> res, int pos){
        if(pos == s.length()){
            return res.size() > 2 ? true : false;
        }

        int num = 0;
        int n = s.length();
        for(int i = pos; i < n; i++){
            num = num * 10 + (s.charAt(i) - '0');
            if(num < 0) return false;
            
            if(res.size() < 2 || res.get(res.size() - 2) + res.get(res.size() - 1) == num){
                res.add(num);
                if(helper(s, res, i+1)) return true;
                res.remove(res.size() - 1);
            }

            if(i == pos && s.charAt(i) == '0') return false;
        }
        return false;
    }
}