题面

求正整数

题解

\(rqy\ dalao\) 学姐的题解 + 我自己的理解。

根据算数基本定理。
一个数可以被唯一分解为：

\[p_{1} ^{k_1} * p_{2} ^{k_2} * …p_{n} ^{k_n} \]

根据组合的知识，它的因子个数显然等于：

\[(k_1 + 1) * (k_2 + 1) * … *(k_n + 1) \]

(它的因子可以从分解它的质数中，任意选取一些质数来拼。)

而这道题如果用贪心的思想来做显然不行，贪心不行只好尝试 \(dp\)。
设 \(f[i][j]\) 表示用了前 \(j\) 个质数，且因数个数为 \(i\) 的最小正整数是多少。
所以得到状态转移方程：

\[f[i][j] = min_{k | i}(f[i / k][j - 1] * p_{j} ^ {k - 1}) \]

表示由状态 \(f[i / k][j - 1]\) 即因子个数为 \(i / k\) 个，用了前 \(j - 1\) 个质数的最小正整数，乘上第 \(j\) 个质数的 \(k - 1\) 次方，根据上面那个因子个数的的公式，在乘了过后因子个数显然会变成 \(i / k * (k - 1 +1) = i\) 个。
稍微想想，当因子个数很多时，数据肯定要用高精，但是高精的状态转移显然复杂度很高。所以考虑取 \(log\)。
所以有： \(log(f[i / k][j - 1] * p_{j} ^ {k - 1}) = f[i / k][j - 1] + (k - 1) * logp_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;
}

标签：正整数,log,int,质数,个数,HNOI2001,因子,num
来源： https://www.cnblogs.com/sjzyh/p/14826177.html