【DP/数学】【CF1061C】 Multiplicity

Description

给定一个序列 $a$，求有多少非空序列 $b$ 满足 $b$ 是 $a$ 的子序列并且 $\forall~k~\in~[1,len_b],~~k \mid b_k$，其中 $len_b$ 是 $b$ 的长度。答案对 $1e9+7$ 取模

Input

第一行是序列 $a$ 的长度 $n$

下面一行 $n$ 个整数，代表序列 $a$

Output

输出一行一个整数代表答案

Hint

$1~\leq~n~\leq~100000~,~1~\leq~a_i~\leq~10^6$

Solution

总觉得这题是假的= =

考虑DP。我们设 $f_{i,j}$ 为考虑 $a$ 中前 $i$ 个数，填充到 $b$ 中 $j$ 个的方案数

方程显然：

当 $j~\nmid~a_i$ 时：

$$f_{i,j}~=~f_{i - 1, j}$$

否则：

$$f_{i,j}~=~f_{i - 1}{j}~+~f_{i - 1}{j - 1}$$

考虑这个方程的状态是 $O(n~\max(a_i))$ 的，显然过不去，于是考虑优化：

我们发现能取到第二条转移方程当且仅当 $j$ 是 $a_i$ 的因数，而第一种第一种转移方程可以使用滚动数组直接省略掉。于是我们直接枚举 $a_i$ 的因数，只在因数位置进行转移。同时注意因为 $i$ 相同时的 $f$ 时不能互相影响，所以对因数的转移要从大到小进行

考虑这么做的复杂度：

一共有 $n$ 个数，每个数的因数是 $O(\sqrt{a_i})$，同时排序需要 $O(\sqrt {a_i}~\times~\log (\sqrt{a_i}))$，总复杂度 $O(n~\sqrt{a_i}~\log (\sqrt{a_i}))$。

看起来根本过不去有木有= =

但是考虑因数个数事实上是一个很松的上界，经过实际测试，$[1,10^6]$ 范围内因数个数最多的数的因数不过 $240$ 个，测试结果如下：

于是本题的实际复杂度为 $\Theta(n~\times~d(a_i)~\log (d(a_i)))$，其中 $d(a_i)~\leq~240$

于是就可以轻松通过本题辣

Code

#include <cmath>
#include <cstdio>
#include <vector>
#include <algorithm>
#ifdef ONLINE_JUDGE
#define freopen(a, b, c)
#endif
#define rg register
#define ci const int
#define cl const long long

typedef long long int ll;

namespace IPT {
	const int L = 1000000;
	char buf[L], *front=buf, *end=buf;
	char GetChar() {
		if (front == end) {
			end = buf + fread(front = buf, 1, L, stdin);
			if (front == end) return -1;
		}
		return *(front++);
	}
}

template <typename T>
inline void qr(T &x) {
	rg char ch = IPT::GetChar(), lst = ' ';
	while ((ch > '9') || (ch < '0')) lst = ch, ch=IPT::GetChar();
	while ((ch >= '0') && (ch <= '9')) x = (x << 1) + (x << 3) + (ch ^ 48), ch = IPT::GetChar();
	if (lst == '-') x = -x;
}

template <typename T>
inline void ReadDb(T &x) {
	rg char ch = IPT::GetChar(), lst = ' ';
	while ((ch > '9') || (ch < '0')) lst = ch, ch = IPT::GetChar();
	while ((ch >= '0') && (ch <= '9')) x = x * 10 + (ch ^ 48), ch = IPT::GetChar();
	if (ch == '.') {
		ch = IPT::GetChar();
		double base = 1;
		while ((ch >= '0') && (ch <= '9')) x += (ch ^ 48) * ((base *= 0.1)), ch = IPT::GetChar();
	}
	if (lst == '-') x = -x;
}

namespace OPT {
	char buf[120];
}

template <typename T>
inline void qw(T x, const char aft, const bool pt) {
	if (x < 0) {x = -x, putchar('-');}
	rg int top=0;
	do {OPT::buf[++top] = x % 10 + '0';} while (x /= 10);
	while (top) putchar(OPT::buf[top--]);
	if (pt) putchar(aft);
}

const int maxn = 100010;
const int maxt = 1000010;
const int MOD = 1000000007;

int n;
int MU[maxn];
ll frog[maxt];
std::vector<int>p;

int main() {
	freopen("1.in", "r", stdin);
	qr(n);
	for (rg int i = 1; i <= n; ++i) qr(MU[i]);
	frog[0] = 1;
	for (rg int i = 1; i <= n; ++i) {
		p.clear();
		for (rg int j = 1, sn = sqrt(MU[i]); j <= sn; ++j) if (!(MU[i] % j)) {
			int k = MU[i] / j;
			p.push_back(k); 
			if (k != j) p.push_back(j);
		}
		std::sort(p.begin(), p.end());
		for (rg int j = p.size() - 1; ~j; --j) {
			frog[p[j]] = (frog[p[j]] + frog[p[j] - 1]) % MOD;
		}
	}
	ll ans = 0;
	for (rg int i = 1; i <= n; ++i) ans = (ans + frog[i]) % MOD;
	qw(ans, '\n', true);
	return 0;
}

Summary

一个数的因数个数是 $O(\sqrt{n})$ 是一个非常松的上界，事实上，在100万范围内因数个数最多的数的因数不过240个。遇到更大的范围可以 $O(n \ln n)$ 筛出所有数的因数来取得实际个数。