剑指 Offer 17. 打印从1到最大的n位数——大数打印法、大数相加

剑指 Offer 17. 打印从1到最大的n位数

题目描述

输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。
示例 1:

输入: n = 1
输出: [1,2,3,4,5,6,7,8,9]

说明：

用返回一个整数列表来代替打印
n 为正整数

public int[] printNumbers(int n) {
        int end = (int) Math.pow(10,n) - 1;
        int[] res = new int[end];
        for (int i = 0; i < end; i++) {
            res[i] = i + 1;
        }
        return res;
    }

大数打印解法(参考)：

1. 表示大数的变量类型：

• 无论是short / int / long …类型变量类型，数字的取值范围都是有限的，因此，大数的表示用字符串String类型

2. 生成数字的字符串集：

• 使用int类型时，每轮可通过 +1 生成下个数字，而此方法无法应用至String类型。并且String类型的数字的进位操作效率较低，例如例如 “9999” 至 “10000” 需要从个位到千位循环判断，进位 4 次。

• 观察可知，生成的列表实际上是 nn 位 00 - 99 的 全排列 ，因此可避开进位操作，通过递归生成数字的 String 列表。

3. 递归生成全排列：

• 基于分治算法的思想，先固定高位，向低位递归，当个位已被固定时，添加数字的字符串。例如当 n = 2n=2 时（数字范围 1 - 991−99 ），固定十位为 00 - 99 ，按顺序依次开启递归，固定个位 00 - 99 ，终止递归并添加数字字符串。

全排列代码：

class Solution {
    StringBuilder res;
    int count = 0, n;
    char[] num, loop = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
    public String printNumbers(int n) {
        this.n = n;
        res = new StringBuilder(); // 数字字符串集
        num = new char[n]; // 定义长度为 n 的字符列表
        dfs(0); // 开启全排列递归
        res.deleteCharAt(res.length() - 1); // 删除最后多余的逗号
        return res.toString(); // 转化为字符串并返回
    }
    void dfs(int x) {
        if(x == n) { // 终止条件：已固定完所有位
            res.append(String.valueOf(num) + ","); // 拼接 num 并添加至 res 尾部，使用逗号隔开
            return;
        }
        for(char i : loop) { // 遍历 ‘0‘ - ’9‘
            num[x] = i; // 固定第 x 位为 i
            dfs(x + 1); // 开启固定第 x + 1 位
        }
    }
}

问题：

1. 00, 01, 02, \cdots00,01,02,⋯ 应显示为 0, 1, 2, \cdots0,1,2,⋯ ，即应 删除高位多余的 00 ;
2. 此方法从 00 开始生成，而题目要求 列表从 11 开始 ；

解决：

1. 删除高位多余的 0 ：

字符串左边界定义： 声明变量 start 规定字符串的左边界，以保证添加的数字字符串 num[start:] 中无高位多余的 0 。例如当 n = 2 时， 1 - 9 时 start = 1， 10−99 时 start = 0 。

左边界 start 变化规律： 观察可知，当输出数字的所有位都是 99 时，则下个数字需要向更高位进 11 ，此时左边界 start需要减 1 （即高位多余的 0 减少一个）。例如当 n = 3 （数字范围 1 - 999）时，左边界 start 需要减 11 的情况有： “009” 进位至 “010” ，。设数字各位中 99 的数量为 nine ，所有位都为 99 的判断条件可用以下公式表示：n - start = nine

统计 nine 的方法： 固定第 xx 位时，当 i = 9 则执行 nine = nine + 1 ，并在回溯前恢复 nine = nine - 1 。

2. 列表从 1 开始：
   在以上方法的基础上，添加数字字符串前判断其是否为 “0” ，若为 “0” 则直接跳过

class Solution {
    StringBuilder res;
    int nine = 0, count = 0, start, n;
    char[] num, loop = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
    public String printNumbers(int n) {
        this.n = n;
        res = new StringBuilder();
        num = new char[n];
        start = n - 1;
        dfs(0);
        res.deleteCharAt(res.length() - 1);
        return res.toString();
    }
    void dfs(int x) {
        if(x == n) {
            String s = String.valueOf(num).substring(start);
            if(!s.equals("0")) res.append(s + ",");
            if(n - start == nine) start--;
            return;
        }
        for(char i : loop) {
            if(i == '9') nine++;
            num[x] = i;
            dfs(x + 1);
        }
        nine--;
    }
}

本本题要求int类型数组，可在添加数字字符串s前，将其转化为int类型

class Solution {
    int[] res;
    int nine = 0, count = 0, start, n;
    char[] num, loop = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
    public int[] printNumbers(int n) {
        this.n = n;
        res = new int[(int)Math.pow(10, n) - 1];
        num = new char[n];
        start = n - 1;
        dfs(0);
        return res;
    }
    void dfs(int x) {
        if(x == n) {
            String s = String.valueOf(num).substring(start);
            if(!s.equals("0")) res[count++] = Integer.parseInt(s);
            if(n - start == nine) start--;
            return;
        }
        for(char i : loop) {
            if(i == '9') nine++;
            num[x] = i;
            dfs(x + 1);
        }
        nine--;
    }
}

大数相加

如何将两个100位的数字进行相加？

public static String bigNumSum(String bigNumA,String bigNumB){
        //1.String转为char数组
        //bigNumA，bigNumB 翻转两个字符串后，个位十位相加比较方便
        char[] bigNumAChars = new StringBuffer(bigNumA).reverse().toString().toCharArray();
        char[] bigNumBChars = new StringBuffer(bigNumA).reverse().toString().toCharArray();
        //2.在长的数组长度上加 1 来存储结果
        int resultLength;
        if (bigNumAChars.length > bigNumBChars.length){
            resultLength = bigNumAChars.length;
        }else {
            resultLength = bigNumBChars.length;
        }
        int[] result = new int[resultLength + 1];
        //3.对位相加
        for (int i = 0; i < resultLength; i++) {
            //如果当前的i超过了某个数组的长度，就用0代替高位，和另一个字符数组中的数字相加
            int Aint = i < bigNumAChars.length ? (bigNumAChars[i] - '0') : 0;
            int Bint = i < bigNumBChars.length ? (bigNumBChars[i] - '0') : 0;
            int temp = result[i];
            temp += Aint;
            temp += Bint;
            result[i] = temp;
            //判断是否进位
            if (temp >= 10){
                result[i + 1] = temp / 10;
                result[i] = temp % 10;
            }
        }
        //4. 存储最后的结果
        StringBuffer sb = new StringBuffer();
        //判断最高位是0还是1，0无需保存
        if (result[result.length - 1] == 1){
            sb.append(1);
        }
        for (int i = result.length - 2;i >= 0;i--){
            sb.append(result[i]);
        }
        return sb.toString();
    }