这是 LeetCode 2338「统计理想数组的数目」的 JavaScript 实现，主要利用质因数分解 + 组合数学（隔板法）来解决。
```javascript
/**
* @param {number} n
* @param {number} maxValue
* @return {number}
*/
const idealArrays = (n, maxValue) => {
const MOD = 1e9 + 7;
const limit = maxValue;
// 预处理组合数 C(n+k-1, k)
// 我们需要计算 C(n + len - 1, len)
// 因为 n 最大 1e4，这里 n + 最大指数和大约 2e4
const maxLen = 14; // 2^14 = 16384 > 1e4
const maxComputed = n + maxLen;
// 阶乘与逆元
const fact = new Array(maxComputed + 5);
const invFact = new Array(maxComputed + 5);
fact[0] = 1;
for (let i = 1; i <= maxComputed; i++) {
fact[i] = Number((BigInt(fact[i-1]) * BigInt(i)) % BigInt(MOD));
}
// 快速幂
const powMod = (a, b) => {
let res = 1n;
let base = BigInt(a);
let exp = b;
while (exp > 0) {
if (exp & 1) res = (res * base) % BigInt(MOD);
base = (base * base) % BigInt(MOD);
exp >>= 1;
}
return Number(res);
};
invFact[maxComputed] = powMod(fact[maxComputed], MOD-2);
for (let i = maxComputed-1; i >= 0; i--) {
invFact[i] = Number((BigInt(invFact[i+1]) * BigInt(i+1)) % BigInt(MOD));
}
const comb = (a, b) => {
if (b < 0 || b > a) return 0;
let res = BigInt(fact[a]) * BigInt(invFact[b]) % BigInt(MOD);
res = res * BigInt(invFact[a-b]) % BigInt(MOD);
return Number(res);
};
// 对 1..maxValue 做质因数分解，记录每个数的质因数分解（指数形式）
// 但是不需要所有数，我们只需要对于每个数分解为 p1^e1 * p2^e2 * ...
// 然后对于每个质因子的指数序列，求非递减序列个数 = C(n + len(e) - 1, len(e))，乘起来
let total = 0n;
// 预处理最小质因子，用于快速分解
const spf = new Array(limit + 1);
for (let i = 2; i <= limit; i++) {
if (!spf[i]) {
spf[i] = i;
for (let j = i*i; j <= limit; j += i) {
if (!spf[j]) spf[j] = i;
}
}
}
for (let i = 2; i <= limit; i++) {
if (!spf[i]) spf[i] = i;
}
// 对每个数分解质因数，得到指数数组
for (let num = 1; num <= limit; num++) {
let x = num;
const exponents = [];
while (x > 1) {
const p = spf[x];
let cnt = 0;
while (x % p === 0) {
x /= p;
cnt++;
}
exponents.push(cnt);
}
// 如果没有质因子（num=1），指数数组为空
// 对于空数组，C(n+0-1,0)=1
let ways = 1n;
for (const e of exponents) {
// 指数 e 在长度为 n 的数组中非递减（实际是递增，因为必须整除，但指数可以相等）
// 把 e 个相同的球放入 n 个盒子（允许空盒）=> C(n+e-1, e)
ways = ways * BigInt(comb(n + e - 1, e)) % BigInt(MOD);
}
total = (total + ways) % BigInt(MOD);
}
return Number(total);
};
```
核心思路
1. 问题转化
理想数组满足 arr[i] | arr[i+1]（整除）。把每个数用质因数分解表示：
arr[i] = p1^{a_i1} p2^{a_i2} ...
则整除条件等价于每个质因子的指数序列是非递减的。
2. 独立计数
不同质因子独立，对于每个质因子的指数序列，长度为 n，从 0 到某个最大值 e（目标数的指数），求非递减序列个数。
这等价于：把 e 个相同小球放入 n 个盒子（允许空） = C(n+e-1, e)。
3. 组合数计算
n 最大 1e4，指数 e 最大约 log₂(maxValue) ≤ 14，因此 n+e-1 ≤ 10013，可直接预处理阶乘和逆元。
4. 遍历 1..maxValue
对每个数质因数分解，得到各质因子指数，将每个指数对应的组合数相乘，累加所有数的结果。
时间复杂度
· 预处理阶乘、逆元：O(n + log MOD)
· 每个数质因数分解：O(log maxValue)
· 总复杂度：O(maxValue log maxValue)
示例
```javascript
console.log(idealArrays(2, 5)); // 10
console.log(idealArrays(5, 3)); // 11
```
该解法能高效通过大数据范围约束。
