[HNOI2001] 求正整数

题面

求正整数

题解

$rqydalao$ 学姐的题解 + 我自己的理解。

根据算数基本定理。
一个数可以被唯一分解为：
$$p_1^{k_1}\ast p_2^{k_2}\ast \dots p_n^{k_n}$$
根据组合的知识，它的因子个数显然等于：
$$(k_1+1)\ast (k_2+1)\ast \dots \ast (k_n+1)$$
(它的因子可以从分解它的质数中，任意选取一些质数来拼。)

而这道题如果用贪心的思想来做显然不行，贪心不行只好尝试 $dp$。
设 $f[i][j]$ 表示用了前 $j$ 个质数，且因数个数为 $i$ 的最小正整数是多少。
所以得到状态转移方程：
$$f[i][j]=mi{n}_{k|i}(f[i/k][j-1]\ast p_j^{k-1})$$
表示由状态 $f[i/k][j-1]$ 即因子个数为 $i/k$ 个，用了前 $j-1$ 个质数的最小正整数，乘上第 $j$ 个质数的 $k-1$ 次方，根据上面那个因子个数的的公式，在乘了过后因子个数显然会变成 $i/k\ast (k-1+1)=i$ 个。
稍微想想，当因子个数很多时，数据肯定要用高精，但是高精的状态转移显然复杂度很高。所以考虑取 $log$。
所以有： $log(f[i/k][j-1]\ast p_j^{k-1})=f[i/k][j-1]+(k-1)\ast log{p}_j$
因为所有的 $f[i][j]$ 都是取了 $log$ 的，所以那个 $f[i/k][j-1]$ 出来之后自然就不要 $log$ 了。
因为 $f[i][j]$ 只能从因子个数整除 $i$ 的状态转移，所以我们可以记录一下哪些状态是整除 $m$ 的，只从它们转移，因为我们最后只需要 $m$ 的状态嘛。
跑完 $dp$ 之后自然就是找路径，因为我们要输出的是原本的值，加一个高精乘单精就好了。
转移过程在代码中。

代码

抄的 $rqy$ 学姐的 $tao...$
$m$ 在代码中定义成了变量 $n$

#include<cstdio>
#include<cmath>
#include<iostream>

const int M = 1e5 + 5;
const int p[20] = {//注意是从 0 开始，和状态的那个不同
	2,  3,  5,  7, 11,
    13, 17, 19, 23, 29,
    31, 37, 41, 43, 47,
    53, 59, 61, 67, 71
};

int n,m,d[505];
double f[505][20],logp[20];

struct Mul {
	int num[M],len;
	inline void mul(int x) {
		int v = 0;
		for(int i = 0; i < len; i++) {
			v = (num[i] = num[i] * x + v) / 10;
			num[i] %= 10;
		}
		while(v) num[len++] = v % 10,v /= 10;
	}
}A;

int main() {
	scanf("%d",&n);
	for(int i = 1; i <= n; i++) if(n % i == 0) d[m++] = i;//注意这个是 m++
	for(int i = 0; i < 20; i++) f[0][i] = 0.0;
	for(int i = 0; i < 20; i++) logp[i] = log(p[i]);
	for(int i = 1; i <= m; i++) {
		for(int k = 0; k < 20; k++) f[i][k] = 1e9;
		for(int j = 0; j < i; j++) {
			if(d[i] % d[j]) continue;//d数组相当于是到因子个数为d[]的映射
			int t = d[i] / d[j];
			for(int k = 1; k < 20; k++)
				f[i][k] = std::min(f[i][k],f[j][k - 1] + (t - 1) * logp[k - 1]);
		}
	}
	A.num[0] = A.len = 1;
	int j = 0;
	// 这一步是找出因子个数为 n 的最小正整数
	for(int i = 0; i < 20; i++) if (f[m - 1][i] < f[m - 1][j]) j = i;//m - 1 是因为上面是 m++
	for(int i = m - 1, nxt; i; i = nxt,j--) {
    for(nxt = 0; d[i] % d[nxt] || f[i][j] < f[nxt][j - 1]
        + logp[j - 1] * (d[i] / d[nxt] - 1) - 1e-5; nxt++);
     // 暴力找出当前状态是由哪个状态转移过来的，注意要加1e-5，因为在转移过程中会掉精度
    for (int k = 1; k < d[i] / d[nxt]; k++)
      A.mul(p[j - 1]);// 给答案乘上 pj 的 k - 1 次方
    }
	while (A.len--) printf("%d", A.num[A.len]);
	return 0;
}