【省内训练2018-11-25】Factorization

最新推荐文章于 2020-01-02 20:59:52 发布

cz_xuyixuan

最新推荐文章于 2020-01-02 20:59:52 发布

阅读量346

点赞数

CC 4.0 BY-SA版权

分类专栏：【类型】做题记录【算法】洲阁筛/Min25筛【资料】STL 【算法】搜索与剪枝

本文链接：https://blog.youkuaiyun.com/qq_39972971/article/details/84564043

【类型】做题记录同时被 3 个专栏收录

767 篇文章

订阅专栏

【算法】搜索与剪枝

23 篇文章

订阅专栏

【资料】STL

17 篇文章

订阅专栏

本文介绍了一种基于线性筛法的质因数分解算法，并通过递归调用work函数来处理特定条件下的数对答案贡献。该算法首先筛选出N√N内的质数，然后使用work函数处理质因子乘积不超过x且质因子的指数信息为z的数对答案的贡献，优化了算法的时间复杂度。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

【思路要点】

用类似 $M i n 25$ 筛的过程进行搜索即可。
具体来说，先用线性筛得出 $\sqrt{N}$ 以内的质数，记 $prime_i$ 表示第 $i$ 个质数。
定义过程 $w o r k (x, y, z)$ 表示处理大于等于 $prime_y$ 的质因子乘积不超过 $x$ ，小于 $prime_y$ 的质因子的指数信息为 $z$ 的数对答案的贡献。
我们需要处理的即为 $work(N,1,\empty)$ 。
对于 $w o r k (x, y, z)$ ，我们将大于等于 $prime_y$ 的质因子乘积为质数的数单独处理，显然，这些数是属于一类的，其个数即为 $prime_y,x]$ 中质数的个数，可以事先筛出。
否则，枚举下一个质因数 $prime_i$ ，满足 $prime_i^2≤x,prime_i≥prime_y$ ，并枚举其指数 $e$ ，满足 $prime_i^{e+1}≤x$ ，调用 $work(\lfloor\frac{x}{prime_i^e}\rfloor,i,z+e)$ 即可。
时间复杂度 $O(\frac{N}{Poly(LogN)}*\alpha)$ ，其中 $\alpha$ 为统计答案带来的复杂度因子。

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
typedef long long ll;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
ll n, val[MAXN], cnt[MAXN];
int limit, m, home1[MAXN], home2[MAXN];
map <vector <int>, ll> ans;
int tot, prime[MAXN], f[MAXN];
void getans(ll x, int y, vector <int> now) {
	now.push_back(1);
	sort(now.begin(), now.end(), [&] (int x, int y) {return x > y; });
	ll delta = -(y - 1);
	if (x <= limit) delta += cnt[home1[x]];
	else delta += cnt[home2[n / x]];
	if (delta > 0) ans[now] += delta;
}
void sieve() {
	for (ll i = 1, nxt; i <= n; i = nxt + 1) {
		ll tmp = n / i;
		val[++m] = tmp;
		cnt[m] = tmp - 1;
		if (tmp <= limit) home1[tmp] = m;
		else home2[n / tmp] = m;
		nxt = n / tmp;
	}
	for (int i = 1; i <= tot; i++) {
		for (int j = 1; 1ll * prime[i] * prime[i] <= val[j]; j++) {
			ll tmp = val[j] / prime[i]; int pos = 0;
			if (tmp <= limit) pos = home1[tmp];
			else pos = home2[n / tmp];
			cnt[j] -= cnt[pos] - (i - 1);
		}
	}
}
void work(ll x, int y, vector <int> now) {
	getans(x, y, now);
	if (x < prime[y] || y > tot) return;
	for (int i = y; i <= tot && 1ll * prime[i] * prime[i] <= x; i++) {
		ll val = prime[i], tmp = 1ll * prime[i] * prime[i];
		for (int j = 1; tmp <= x; j++, val = tmp, tmp *= prime[i]) {
			vector <int> tnow = now;
			tnow.push_back(j + 1);
			sort(tnow.begin(), tnow.end(), [&] (int x, int y) {return x > y; });
			ans[tnow]++;
			now.push_back(j);
			work(x / val, i + 1, now);
			now.pop_back();
		}
	}
}
void init(int n) {
	for (int i = 2; i <= n; i++) {
		if (f[i] == 0) prime[++tot] = f[i] = i;
		for (int j = 1; j <= tot && prime[j] <= f[i]; j++) {
			int tmp = prime[j] * i;
			if (tmp > n) break;
			f[tmp] = prime[j];
		}
	}
}
int main() {
	read(n);
	limit = sqrt(n) + 1;
	init(limit + 100);
	sieve();
	vector <int> tmp;
	tmp.clear();
	work(n, 1, tmp);
	printf(": 1\n");
	for (auto x : ans) {
		static int cnt[36];
		ll ans = x.second;
		memset(cnt, 0, sizeof(cnt));
		for (auto y : x.first) {
			printf("%d ", y);
			ans *= ++cnt[y];
		}
		printf(": %lld\n", ans);
	}
	return 0;
}