CF1603C Extreme Extension （数论+dp）

CF1603C Extreme Extension

upd 2024.11.14

数论+dp

首先要思考的一定是怎么操作操作次数会最小。然后就会发现一种贪心策略，即让每次分裂出来的最前面的数尽可能大。

求它的所有非空子段的极端值之和不好直接求，但它等价于求每个位置可能的操作次数（可重）之和。（答案的转化）

由上面可以发现，一个数的操作次数只与上一个数操作后的最前面的数有关，也就是说与前面的数无关，所以对最后的这个数的操作次数只有系数的影响。

那我们就考虑 dp 求解每个位置的贡献。维护什么贡献？

”如果知道上一个位置操作后的最前面的数，也就知道现在位置的操作次数“（充分不必要），那我们只需要知道有多少个子段能够得到这个操作次数就好了。

所以设状态 \(f_{i,v}\) 表示有多少以 \(a_i\) 为开头的子段，使得 \(a_i\) 拆分完之后最小值为 \(v\)。转移 \(f_{i,p}\leftarrow f_{i+1,v}\)。

复杂度 \(O(nV)\)。怎么优化？需要注意到下取整的性质，每个 \(a_i\) 最多只有 \(\sqrt{a_i}\) 种取值。所以每个阶段最多有根号级别的转移量，那我们只需要枚举这些数就行了。

拿到一题有神秘操作的题目，先考虑把神秘操作搞清楚

对于一个子段，最末尾的数一定不能动，考虑从后往前贪心，当出现 \(a_i>a_{i+1}\) 时，需要将 \(a_i\) 拆分。要使当前操作最优，我们要让拆分完的第一个数尽可能大，手算一下就可以得出结论：一共需要拆分 \(\lceil \frac{a_i}{a_{i+1}}\rceil-1\) 次，第一个数的最大值为 \(\lfloor\frac{a_i}{\lceil \frac{a_i}{a_{i+1}}\rceil}\rfloor\)。

此时根据 \(a_i\) 只被 \(a_{i+1}\) 影响，可以考虑 dp，设 \(f_{i,v}\) 表示有多少以 \(a_i\) 为开头的子段，使得 \(a_i\) 拆分完之后最小值为 \(v\)。

考虑转移，朴素的做法，枚举所有 \(f_{i+1,x}\)，此时 \(c=\lceil \frac{a_i}{a_{i+1}}\rceil\)，\(p=\lfloor\frac{a_i}{c}\rfloor\)，转移到对应的 \(f_{i,p}\) 中，复杂度为 \(O(nV)\)，无法通过。

发现对于每一个 \(i+1\)，最多只能转移到 \(\sqrt{a_{i+1}}\) 个状态中，而对于每个 \(i\)，也只有 \(\sqrt{a_{i+1}}\) 个状态不为零，可以继续转移。这个结论可以用数论分块证明。

所以考虑优化 dp，首先滚动数组，空间复杂度为 \(O(n)\)。用两个 vector 维护，将 \(i+1\) 的所有不为零的状态用 vector 存起来，转移到对应的 \(f_{i,p}\) 里。再将 \(i\) 中不为零的状态用另一个 vector 存起来。

考虑按位计算答案，对于每个 \((i,v)\)，贡献为 \(i\times (c-1)\times f_{i,v}\)，乘法满足分配律，我们在转移的同时更新答案即可。

复杂度降到 \(O(n\sqrt V)\) 。

#include <bits/stdc++.h>

typedef long long i64;

const int mod = 998244353;

void Solve() {
	int n;
	std::cin >> n;

	std::vector<int> a(n + 1);

	int mx = 0;
	for(int i = 1; i <= n; i++) {
		std::cin >> a[i];
		mx = std::max(mx, a[i]);
	}

	std::vector<std::vector<int>> dp(2, std::vector<int> (mx + 1));
	std::vector<int> v[2];
	int op = 1;
	i64 ans = 0;
	for(int i = n; i >= 1; i--) {
		dp[op][a[i]] = 1;
		v[op].push_back(a[i]);
		int lst = a[i];
		for(auto x : v[op ^ 1]) {
			int cnt = (a[i] + x - 1) / x;
			int num = a[i] / cnt;
			ans = (ans + (i64)i * (cnt - 1) % mod * dp[op ^ 1][x]) % mod;
			dp[op][num] += dp[op ^ 1][x];
			if(num != lst) {
				v[op].push_back(num), lst = num;
			}
		}	
		for(auto x : v[op ^ 1]) {
			dp[op ^ 1][x] = 0;
		}
		v[op ^ 1].clear();
		op ^= 1;
	} 

	std::cout << ans << "\n";
}
int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
	
	int t;
	std::cin >> t;

	while(t--) Solve();

	return 0;
}