【探索-字节跳动】字符串相乘

题目中已经限制了算法的实现途径，即不能用 Java 中现成的 API 去实现，也不能直接转换为整形去相乘。

而且这里会涉及到大数，所以我的想法是利用我们手写乘法时的规则饿，将 num1 和 num2 中位数较长的去直接乘以 位数较短的每一位，然后依次把结果加起来即可。

// 执行用时：32 ms
public String multiply(String num1, String num2) {
    if ("0".equals(num1)||"0".equals(num2)) return "0";
    int[] arr1;
    int[] arr2;
    arr1 = new int[num1.length()];
    for (int i = 0; i < num1.length(); i++) {
        arr1[i] = num1.charAt(i) - '0';
    }
    arr2 = new int[num2.length()];
    for (int i = 0; i < num2.length(); i++) {
        arr2[i] = num2.charAt(i) - '0';
    }
    // arr1 为较长的字符串，arr2 为较短的
    if (arr2.length>arr1.length) {
        int[] tmp = arr1;
        arr1 = arr2;
        arr2 = tmp;
    }
    Map<Integer, int[]> map = new HashMap<>();
    // result 的位数为 num1 * num2 能达到的最大位数
    int[] result = new int[arr1.length + arr2.length];
    int arr2Len = arr2.length;
    // 用 num2 的每一位去乘以 num1
    for (int i = arr2Len-1; i >= 0; i--) {
        int n = arr2[i];
        int[] tmp;
        if (map.containsKey(n)) {
            tmp = map.get(n);
        } else {
            tmp = getCurrentNumProduct(n, arr1);
            map.put(n, tmp);
        }
        int[] tmp2 = new int[tmp.length + (arr2Len - 1 - i)];
        // 得到与位数无关的积然后低位补 0（没有设置的位数默认为 0）
        System.arraycopy(tmp, 0, tmp2, 0, tmp.length);
        // 将每位求得的结果累加
        plus(result, tmp2);
    }
    StringBuilder builder = new StringBuilder(result.length);
    int i = 0;
    // 从高位首个非 0 元素开始
    while (result[i]==0) ++i;
    for (; i < result.length; i++) {
        builder.append((char)(result[i]+'0'));
    }
    return builder.toString();
}

// arr2 中的当前位去乘以 arr1，得到无关于位数的结果
private static int[] getCurrentNumProduct(int n, int[] nums) {
    if (n==0) return new int[]{0};
    int flag = 0;
    int[] result = new int[nums.length + 1];
    // 因为 result 的长度为 nums.length+1，所以最低位为 index = nums.length
    for (int i = nums.length;i > 0; i--) {
        flag = flag + n * nums[i-1];
        result[i] = flag % 10;
        flag = flag / 10;
    }
    result[0] = flag;
    return result;
}

private void plus(int[] num1,int[] num2) {
    // 从最低位加起
    int flag = 0;
    int i1 = num1.length - 1, i2 = num2.length - 1;
    while (i1 >= 0 && i2 >= 0) {
        flag = num1[i1] + num2[i2] + flag;
        num1[i1] = flag % 10;
        flag = flag/10;
        --i1;
        --i2;
    }
    while (flag > 0) {
        flag = flag + num1[i1];
        num1[i1] = flag % 10;
        flag = flag / 10;
    }
}

算法总体分为两部分，一部分是实现用较长的去乘以较短的每一位，求出该段的结果，但是这个结果是无关位数的，比如 123 * 45，这里用 123 * 4 得到的结果，还需要在低位补 0，因为本质上是用 123 * 40。

因为只包含数字 0-9，因此 arr2 中的每一个分别乘 arr1 得到的无关位的结果，最多也就 9 种，因为在实现中还借助了一个 Map 来存储 arr2[i] * arr1 的结果，这样就可以减少重复计算。

只不过，在整个的实现过程中，num1 与 num2 中元素下标大的，对应的是数学中的低位。比如 “123”，其中 “3” 的下标为 2，但是对应的是数学中的个位。

---

然后有看到提交记录里面一个执行用时为 11 ms 的范例

public String multiply(String num1, String num2) {
    if(num1.isEmpty() || num2.isEmpty()
            ||(num1.length() == 1 && num1.charAt(0) == '0')
            || (num2.length() == 1 && num2.charAt(0) == '0'))
        return "0";
    int len1 = num1.length();
    int len2 = num2.length();
    int[] ans = new int[len1 + len2 + 1];
    // 从高位开始，先将 num1 与 num2 的每位分对应相乘，且暂时不处理进位
    // 且这里就把每位乘积的结果从高为映射到数组的较小的下标
    // 比如 "12" * "34"，其中 1*3 的结果在数学中应该处于高位，
    // 但是会被存储到 ans 中下标较小的位置，与 num1 和 num2 的表示规则相反
    for(int i = 0 ; i < len1;i++) {
        int a = num1.charAt(i) - '0';
        for(int j = 0; j < len2; j++) {
            int b = num2.charAt(j) - '0';
            ans[len1 + len2 - i - j - 2] += a * b ;
        }
    }
    // 经过上述处理后，如 “99” * “99”，就会为
    // (81)[0] (81+81)[1] (81)[2]
    // 其中弧括号内的为乘积，方括号代表在 ans 中的下标
    StringBuffer res = new StringBuffer();
    // 处理进位
    for(int i = 0; i < len1 + len2   ;i++) {
        res.append(ans[i] % 10);
        ans[i + 1] += ans[i] / 10;
    }
    // 因为是先从低位（下标较小的）开始处理，因为最后还需要反转一下，
    // 将高位转换到前面（即将高位转换到下标较小的位置）
    String result = res.reverse().toString();
    if(result.startsWith("0"))
        result = result.substring(1, len1 + len2);
    return result;
}

然后我自己也按照上述思想重新实现来一遍，只不过原算法是将 num1 和 num2 中每位相乘的乘积，本身在高位的，转换到了下标较小的位置。但是我在实现的时候还是按照原本的操作，将高位映射在下标较大的位置。

// 执行用时：16 ms
public String multiply(String num1, String num2) {
    if(num1.isEmpty() || num2.isEmpty()
            ||(num1.length() == 1 && num1.charAt(0) == '0')
            || (num2.length() == 1 && num2.charAt(0) == '0'))
        return "0";
    int len1 = num1.length();
    int len2 = num2.length();
    int[] ans = new int[len1 + len2];
    int tmp = ans.length - len1 - len2 + 1;
    // 先将 num1 与 num2 的每位分对应相乘，且暂时不处理进位
    for(int i = len1-1 ; i >=0;i--) {
        int a = num1.charAt(i) - '0';
        for(int j = len2-1; j >=0; j--) {
            int b = num2.charAt(j) - '0';
            ans[tmp + i + j] += a * b ;
        }
    }
    // 处理进位
    for(int i = len1+len2 - 1; i >=1   ;i--) {
        ans[i - 1] += ans[i] / 10;
        ans[i] = ans[i] % 10;
    }
    StringBuilder res = new StringBuilder();
    int i = (ans[0])>0 ? 0 :1;
    for (; i < ans.length; i++) {
        res.append(ans[i]);
    }
    return res.toString();
}

其中下标映射的操作：

ans[(ans.length - len1 -len2 + 1 + i + j)]

本质上是由

int tmp = ans.length - len1 - len2 + 1;
ans[(ans.length - 1) - ((len1 - 1 - i ) + (len2 - 1 - j ))]

化简而来的，只不过先把固定结果部分的表达式先计算出来，而不是每次都重复计算，提高效率。