数论分块与动态规划算法实战解析

1. 题目解析与算法思路详解

1.1 T1：平平无奇的数学题

这道题目要求计算从1到n的所有⌊n/i⌋之和。直接暴力计算的时间复杂度是O(n)，当n很大时（比如1e12）会非常低效。我们需要更聪明的数学方法——数论分块。

数论分块的核心观察是：对于i∈[1,n]，⌊n/i⌋的值会形成若干个连续的区间。例如当n=10时：

• i=1-10：⌊10/1⌋=10
• i=2-5：⌊10/2⌋=5
• i=6-10：⌊10/3⌋=3
• ...

每个区间的右端点可以通过r = n/(n/i)计算得到。这样我们就能把O(n)的计算优化到O(√n)。

关键技巧：对于每个区间[l,r]，贡献值为(r-l+1)*(n/l)。这样我们只需要遍历所有不同的n/i值区间即可。

1.2 T2：差的平方

这道题要求计算所有无序数对(ai,aj)的差的平方之和。直接双重循环的O(n²)解法显然不适用于大数据量。

我们可以通过数学展开来优化：
∑(ai-aj)² = ∑(ai² - 2aiaj + aj²) = n∑ai² - 2∑ai∑aj

利用前缀和数组可以高效计算：

• s[i] = a1 + a2 + ... + ai
• s2[i] = a1² + a2² + ... + ai²

这样对于每个i，它对答案的贡献就是：
(i-1)ai² - 2ai*s[i-1] + s2[i-1]

1.3 T3：变成1

这是一个典型的动态规划问题。我们需要为每个数字计算变成1的最小操作次数。

定义dp[i]为将i变成1的最小操作次数。转移方程有两种情况：

1. 通过减1操作：dp[i] = dp[i-1] + 1
2. 通过除以某个质因数p：dp[i] = min(dp[i], dp[i/p] + 1)

预处理质数可以使用埃拉托斯特尼筛法，同时记录每个数的最小质因数，这样可以在O(n log log n)时间内完成预处理。

1.4 T4：上课安排

这是经典的区间调度问题，但目标是最优化总时长而非课程数量。

解法步骤：

1. 按结束时间排序所有课程
2. 定义dp[i]表示前i节课能获得的最大总时长
3. 对于每节课i，找到最后一个不与它冲突的课程j（可以用二分查找）
4. 状态转移：dp[i] = max(dp[i-1], dp[j] + duration[i])

1.5 T5：区间求和

这道题需要统计乘积为负、正、零的子数组数量。直接枚举所有子数组的O(n²)方法不够高效。

我们可以使用动态规划：

• dp[i][0]：以i结尾乘积为0的子数组数
• dp[i][1]：以i结尾乘积为正的子数组数
• dp[i][2]：以i结尾乘积为负的子数组数

转移规则根据当前元素的值有所不同：

• 如果a[i]=0，则只能从dp[i-1][0]转移
• 如果a[i]>0，保持前一个状态的符号
• 如果a[i]<0，反转前一个状态的符号

1.6 T6：倒牛奶

这是一个状态空间搜索问题，可以使用BFS来探索所有可能的倒奶状态。

关键点：

1. 状态表示：(a,b,c)表示三个桶中的牛奶量
2. 每次操作有6种可能的倒法（A→B, A→C, B→A, B→C, C→A, C→B）
3. 使用三维数组vis记录已访问状态避免重复
4. 当任一桶的牛奶量达到v/2时返回当前步数

2. 代码实现与优化技巧

2.1 T1优化实现

cpp复制#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

int main() {
    ll n, ans = 0;
    cin >> n;
    for(ll l = 1, r; l <= n; l = r + 1) {
        ll val = n / l;
        r = n / val;
        ans += (r - l + 1) * val;
    }
    cout << ans;
    return 0;
}

优化点：

1. 使用long long防止溢出
2. 直接计算区间右端点，避免浮点运算
3. 循环变量更新为r+1，确保不重复计算

2.2 T2前缀和优化

cpp复制#include<bits/stdc++.h>
using namespace std;
const int MOD = 1e9+7;

int main() {
    int n; cin >> n;
    vector<long long> a(n+1), s(n+1), s2(n+1);
    for(int i=1; i<=n; i++) {
        cin >> a[i];
        s[i] = (s[i-1] + a[i]) % MOD;
        s2[i] = (s2[i-1] + a[i]*a[i]) % MOD;
    }
    
    long long ans = 0;
    for(int i=1; i<=n; i++) {
        long long term1 = (i-1) * (a[i]*a[i] % MOD) % MOD;
        long long term2 = 2 * a[i] % MOD * s[i-1] % MOD;
        long long term3 = s2[i-1];
        ans = (ans + term1 - term2 + term3 + MOD) % MOD;
    }
    cout << ans;
    return 0;
}

注意事项：

1. 模运算要频繁进行，防止溢出
2. 减法后要加MOD再取模，避免负数
3. 使用vector代替原生数组更安全

2.3 T3动态规划实现

cpp复制#include<bits/stdc++.h>
using namespace std;
const int MAX = 1e6+5;

int dp[MAX];
vector<int> primes[MAX];

void sieve() {
    for(int i=2; i<MAX; i++) {
        if(primes[i].empty()) {
            for(int j=i; j<MAX; j+=i) {
                primes[j].push_back(i);
            }
        }
    }
}

int main() {
    sieve();
    dp[1] = 0;
    for(int i=2; i<MAX; i++) {
        dp[i] = dp[i-1] + 1;
        for(int p : primes[i]) {
            dp[i] = min(dp[i], dp[i/p] + 1);
        }
    }
    
    int T; cin >> T;
    while(T--) {
        int n; cin >> n;
        cout << dp[n] << endl;
    }
    return 0;
}

优化技巧：

1. 预处理质因数分解
2. 线性筛法优化空间
3. 动态规划自底向上计算

3. 常见问题与调试技巧

3.1 T1边界条件处理

常见错误：

1. 整数溢出：当n很大时，中间计算结果可能超出int范围
2. 循环终止条件错误：确保覆盖所有i值

调试方法：

• 打印中间变量值，验证分块是否正确
• 测试n=1, n=1e12等边界情况

3.2 T2模运算问题

常见陷阱：

1. 减法取模未处理负数
2. 乘法未及时取模导致溢出
3. 累加未取模

解决方案：

cpp复制// 正确写法示例
ans = (ans + term1) % MOD;
ans = (ans - term2 + MOD) % MOD; 
ans = (ans + term3) % MOD;

3.3 T3性能优化

当n很大时(1e6)，需要注意：

1. 筛法预处理要高效
2. DP数组使用线性空间
3. 查询阶段直接O(1)回答

3.4 T4贪心选择证明

为什么按结束时间排序是最优的？

• 这样可以在早期腾出更多时间给后续课程
• 数学归纳法可以证明其正确性

3.5 T5状态转移验证

如何验证DP转移的正确性？

• 手动计算小例子(n=3)的所有子数组
• 对比DP结果与暴力计算结果
• 特别注意a[i]=0时的状态转移

3.6 T6状态哈希优化

当桶容量很大时(200)，三维状态会占用很多内存。可以考虑：

1. 使用位压缩存储状态
2. 使用unordered_map代替三维数组
3. 优先队列优化BFS

4. 算法复杂度分析

4.1 时间复杂度比较

4.2 空间复杂度分析

1. T1-T2：O(1)额外空间
2. T3：O(n)筛法和DP数组
3. T4：O(n)存储区间和DP
4. T5：O(n)DP数组
5. T6：O(vxy)状态空间

4.3 实际运行效率

在n=1e6量级时：

• T1优化后仅需约1e3次迭代
• T2前缀和解法可在10ms内完成
• T3预处理后查询是O(1)的
• T4排序是主要耗时点
• T5线性扫描非常高效
• T6取决于v,x,y的大小

5. 扩展思考与变种问题

5.1 T1的数学背景

这个求和式实际上是除数函数d(n)的前缀和，即D(n)=∑d(i) for i=1..n，其中d(i)是i的正除数个数。数论分块技巧在计算数论函数前缀和时非常有用。

5.2 T2的更高维推广

如果要求计算三维数组的差的平方和，可以类似展开：
∑(ai-aj-ak)² = ...

同样可以使用前缀和技巧优化，但需要更高维的前缀和数组。

5.3 T3的操作代价变化

如果不同操作有不同的代价（比如减1操作代价为2，除法代价为1），问题就变成了带权最短路问题，可以用Dijkstra算法解决。

5.4 T4的资源约束扩展

如果有多个教室可用（即允许最多k节课时间重叠），问题就变成了带资源约束的区间调度，可以用贪心+堆的解法。

5.5 T5的乘积范围查询

如果问题改为查询区间乘积在某个范围内的子数组数量，可以使用前缀积+离散化+树状数组的方法。

5.6 T6的更多桶情况

如果有k个牛奶桶，状态空间会呈指数增长，这时需要更智能的搜索策略，如A*算法。