【LeetCode】第306题——累加数（难度：中等）

题目描述

累加数是一个字符串，组成它的数字可以形成累加序列。

一个有效的累加序列必须至少包含 3 个数。除了最开始的两个数以外，字符串中的其他数都等于它之前两个数相加的和。

给定一个只包含数字 ‘0’-‘9’ 的字符串，编写一个算法来判断给定输入是否是累加数。

说明: 累加序列里的数不会以 0 开头，所以不会出现 1, 2, 03 或者 1, 02, 3 的情况。

1. 示例 1:
   输入: “112358”
   输出: true
   解释: 累加序列为: 1, 1, 2, 3, 5, 8 。1 + 1 = 2, 1 + 2 = 3, 2 + 3 = 5, 3 + 5 = 8

2. 示例 2:
   输入: “199100199”
   输出: true
   解释: 累加序列为: 1, 99, 100, 199。1 + 99 = 100, 99 + 100 = 199

进阶:你如何处理一个溢出的过大的整数输入?

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/additive-number
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

回溯+剪枝

拿示例2为例讲解一下过程，num为“199100199”

1. 取得第一个数字1
2. 取得第二个数字9，1+9=10
3. 取得第三个数字9，9<10，更改第三个数字（剪枝）
4. 更改第三个数字91，91>10，说明第二个数字获取错误（此时第一个数字是否获取错误未知），更改第二个数字（回溯）
5. 更改第二个数字为99，1+99=100
6. 取第三个数字为1，1<100，更改第三个数字（剪枝）
7. 更改第三个数字为10，10<100，更改第三个数字（剪枝）
8. 更改第三个数字为100，100=100，可以继续取第四个数字了，且第二、三数字之和为99+100=199
9. 取第四个数字为1，1<199，更改第四个数字（剪枝）
10. 更改第四个数字为19，19<199，更改第四个数字（剪枝）
11. 更改第四个数字为199，199=199，且此时已遍历至字符串末，可以返回true

上面的例子只是为了更好地说明步骤，有一些特殊情况未体现出来，我们重点看一下代码

代码详解

class Solution {
    public boolean isAdditiveNumber(String num) {
        return func1(num, num.length(), 0, 0, 0, 0);
    }

    public boolean func1(String n, int len, int index, long sum, long pre, int count) {
        /*
        	此方法递归体
            String n    原字符串
            int len     原字符串长度
            int index   遍历的当前下标
            long sum    当前数字和前一数字之和（此“当前”和“前一”所处的时机是调用此方法时，而不是执行此方法时）
            long pre    前一数字
            int count   第几个数字
        */
        if(index == len) {
            return count > 2;	// 若遍历完后发现数字个数小于3，不能形成所谓的“累加”，返回false
        }
        // 这个for循环可以结合上一小节的例子，更容易理解
        for(int i = index; i < len; ++i) {
            long cur = func2(n, index, i);	// 得出当前数字，用long来避免越int的界，但仍只是缓兵之计，真正一劳永逸的解决思路放在下一小节中
            if(cur == -1) {	// -1说明在执行fun2()时出现了02一样的以0开头的多位数，这是不允许的
                continue;
            }
            if(count >= 2 && cur != sum) {	// 若已有两个数字，此两数之和不等于当前数字时
                if(cur > sum) {	// 这个if可提前终止当前for循环，体现在上一小节示例中的第四步
                    return false;
                }
                continue;
            }
            if(func1(n, len, i+1, pre+cur, cur, count+1)) {	// 递归
                return true;
            }
        }
        return false;
    }

    public long func2(String n, int p, int q) {
        /*
            求当前数字值 String -> long
            String n    原字符串
            int p       左指针
            int q       右指针，与左指针一起确定被左右指针夹中间的数字
        */
        if(p < q && n.charAt(p) == '0') {
            return -1;	// 不能出现01、02之类的零几的数字
        }
        long res = 0;	// 累加和，用long只是暂时防止数值过大超过int，但仍有超过long的情况，在下一小节再说明一下最没问题的思路
        while(p <= q) {
            res = res * 10 + n.charAt(p) - '0';	// 累加
            ++p;
        }
        return res;
    }
}

注意点

1. 可以通过if(cur > sum)这一判断，提前确定何时发生回溯
2. 对于进阶问题，把int变为long只是缓兵之计，最一劳永逸的办法是执行字符串相加减，类似小学学的竖式相加（考虑进位）。这样一来不管数据有多大也不用考虑超出基本数据类型界限的情况发生。