目标
给你一个长度为 m 的字符串 s，其中仅包含数字。另给你一个二维整数数组 queries，其中 queries[i] = [li, ri]。
对于每个 queries[i]，提取 子串 s[li..ri]，然后执行以下操作：
- 将子串中所有 非零数字 按照原始顺序连接起来，形成一个新的整数 x。如果没有非零数字，则 x = 0。
- 令 sum 为 x 中所有数字的 数字和 。答案为 x * sum。
返回一个整数数组 answer，其中 answer[i] 是第 i 个查询的答案。
由于答案可能非常大，请返回其对 10^9 + 7 取余数的结果。
子串 是字符串中的一个连续、非空 字符序列。
示例 1：
输入： s = "10203004", queries = [[0,7],[1,3],[4,6]]
输出： [12340, 4, 9]
解释：
s[0..7] = "10203004"
x = 1234
sum = 1 + 2 + 3 + 4 = 10
因此，答案是 1234 * 10 = 12340。
s[1..3] = "020"
x = 2
sum = 2
因此，答案是 2 * 2 = 4。
s[4..6] = "300"
x = 3
sum = 3
因此，答案是 3 * 3 = 9。示例 2：
输入： s = "1000", queries = [[0,3],[1,1]]
输出： [1, 0]
解释：
s[0..3] = "1000"
x = 1
sum = 1
因此，答案是 1 * 1 = 1。
s[1..1] = "0"
x = 0
sum = 0
因此，答案是 0 * 0 = 0。示例 3：
输入： s = "9876543210", queries = [[0,9]]
输出： [444444137]
解释：
s[0..9] = "9876543210"
x = 987654321
sum = 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 = 45
因此，答案是 987654321 * 45 = 44444444445。
返回结果为 44444444445 mod (10^9 + 7) = 444444137。说明：
- 1 <= m == s.length <= 10^5
- s 仅由数字组成。
- 1 <= queries.length <= 10^5
- queries[i] = [li, ri]
- 0 <= li <= ri < m
思路
有一个数字字符串 s，针对每一个子串 s[queries[i][0], queries[i][1]]，返回其非零数字所表示的数字 乘以 每位数字之和 对 1000000007 取余的结果。
与 3754.连接非零数字并乘以其数字和I 相比，本题的数字是由 queries 给出的子串，需要返回每一个子串的结果。
数位和可以使用前缀和快速计算。子串非零数字所表示的数字也可以通过前缀计算。
区间 [l, r] 所表示的数字对 MOD 取模的值为 (prefixNum[r + 1] + MOD - prefixNum[l] * base[k] % MOD) % MOD，例如，1230456，[2, 4] 中的非零数字所表示的数字是 34，它等于 prefixNum[5]:1234 - prefixNum[2]:12 * 100，其中 100 = 10^k，k 表示 [l, r] 中非零数字的个数。
代码
/**
* @date 2026-07-08 9:50
*/
public class SumAndMultiply3756 {
public int[] sumAndMultiply(String s, int[][] queries) {
int n = s.length();
int[] prefix = new int[n + 1];
int[] prefixLength = new int[n + 1];
long[] prefixNum = new long[n + 1];
for (int i = 0; i < n; i++) {
int d = s.charAt(i) - '0';
prefix[i + 1] = prefix[i] + d;
prefixLength[i + 1] = prefixLength[i] + (d != 0 ? 1 : 0);
prefixNum[i + 1] = (prefixNum[i] * (d != 0 ? 10 : 1) + d) % MOD;
}
int ql = queries.length;
int[] res = new int[ql];
for (int i = 0; i < ql; i++) {
int l = queries[i][0];
int r = queries[i][1];
int sum = prefix[r + 1] - prefix[l];
long x = (prefixNum[r + 1] + MOD - prefixNum[l] * base[prefixLength[r + 1] - prefixLength[l]] % MOD) % MOD;
res[i] = (int) (x * sum % MOD);
}
return res;
}
}
性能
