@bzoj - 4524@ [Cqoi2016]伪光滑数

目录

• ＠description＠
• @solution@
  • @version - 1@
  • @version - 2@
• @accepted code@
  • @version - 1@
  • @version - 2@
• @details@

---

＠description＠

若一个大于 1 的整数 M 的质因数分解有 k 项，其最大的质因子为 \(A_k\)，并且满足 \(A_k^k \le N\)，\(A_k < 128\)，我们就称整数 M 为 N - 伪光滑数。

现在给出 N，求所有整数中第 K 大的 N - 伪光滑数。

input

只有一行，为用空格隔开的整数 N 和 K 。2 ≤ N ≤ 10^18， 1 ≤ K ≤ 800000，保证至少有 K 个满足要求的数

output

只有一行，为一个整数，表示答案。

sample input

12345 20

sample output

9167

@solution@

首先，如果对于质数 x 以及一个整数 k，满足 \(x^k \le N\)。则只要保证剩下的 k-1 个质因数小于等于 x 就可以构成伪光滑数了。

所以假如我们确定了 x 和 k，题目中给出的关于伪光滑数的约束统统没有用。

@version - 1@

关于求解第 k 大，这里显然二分答案是不可做的（upd in 2019/2/12：还真的被我找到了二分答案的做法……不过我并不打算写因为我太懒了）。我们可以通过类比 k 短路的做法来做。简略地说一下：

当给定 x 和 k 时，显然最大的数是 k 个 x 相乘，我们把这个当作初始状态。考虑设计一个不重复不遗漏的初始状态与某一状态之间的转移，且要使得转移始终是递减的。

假如某状态 \(m = p_1^{a_1}*p_2^{a_2}*\dots*p_r^{a_r}\)，其中 \(p_1<p_2<\dots<p_r=x\)。可以把这个状态看作 \([1, a_1+a_2+\dots+a_r]\) 这些位置填 \(p_r\)，再 \([1, a_1+a_2+\dots+a_{r-1}]\) 这些位置填 \(p_{r-1}\) 并覆盖掉之前填的质因子，然后重复操作……

于是，我们这样来转移：状态里面存储当前的数是什么，最小质因子和次小质因子是什么，最小质因子和次小质因子的出现次数。每次两类转移，次小换最小或者新增更小。前者要保证次小的质因子次数为正。

upd in 2019/2/12：

时间复杂度应该是 O(nlog^2n) 的级别。不过我们要相信玄学，一个数的质因子怎么可能卡得满这个上界。

反正能过啦，管那么多干嘛。

实际上，有一些代码实现可以做到 O(nlog n) 的复杂度，不过我看不懂……

@version - 2@

对于这道题，我们有一个更暴力（应该是吧？毕竟内存消耗更多些）的方法。

我们一样给定 x 和 k。然后对于每一对 （x, k），我们把所有的可能的答案存储在堆内。

当然不可能是直接存，我们使用可持久化左偏树来搞。

定义 \(f(x, k)\) 表示最大的质因子为 x，质因子个数为 k 时的左偏树。

讨论次大的数是什么，可以得到 \(f(x, k)\) 是由所有满足 i <= x 且 i 为质数的左偏树 \(f(i, k-1)\) 全部合并起来再给所有元素乘 x 得到。

后一个操作可以用打 tag 的方式实现。

但是这样空间开销还是很大。我们考虑给左偏树求前缀和。

定义 \(g(x, k)\) 表示所有满足 i <= x 且 i 为质数的左偏树 \(f(i, k)\) 全部合并起来得到的左偏树。

就有 \(g(x, k)\) 等于 \(f(x, k)\) 与 \(g(x-1, k)\)的合并，\(f(x, k)\) 等于 \(g(x, k-1)\) 这棵树整体乘 x。

这样每增加一个状态最多只会多合并一次。

对，f 和 g 都是一个左偏树。

对，你可以理解为左偏树用来作 dp。

对，很神奇，我也没见过。

下传标记的时候记得也要新建结点。

@accepted code@

因为我实在是太懒了，仅给出第二种方法的代码。

upd in 2019/2/12：已经更新了第一种方法的代码啦~

@version - 1@

#include<queue>
#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
const int MAXK = 800000;
struct node{
	int a1, a2, b1, b2; ll c;
	node(int _a1=0, int _a2=0, int _b1=0, int _b2=0, ll _c=0):a1(_a1), a2(_a2), b1(_b1), b2(_b2), c(_c){}
};
bool operator < (node a, node b) {
	return a.c < b.c;
}
bool is_prm(int n) {
	for(int i=2;i<n;i++)
		if( n % i == 0 ) return false;
	return true;
}
int prm[128], pcnt;
priority_queue<node>que;
int main() {
	ll N; int K;
	scanf("%lld%d", &N, &K);
	for(int i=2;i<128;i++) {
		if( !is_prm(i) ) continue;
		prm[++pcnt] = i;
		for(ll nw=1,cnt=1;nw<=N/i;nw*=i,cnt++)
			que.push(node(0, pcnt, 0, cnt, nw*i));
	}
	ll ans;
	for(int i=1;i<=K;i++) {
		node t = que.top(); que.pop();
		if( t.b1 > 1 )
			que.push(node(t.a1, t.a2, t.b1 - 1, t.b2 + 1, t.c/prm[t.a1]*prm[t.a2]));
		if( t.b2 > 1 ) {
			for(int i=1;i<t.a2;i++)
				que.push(node(t.a2, i, t.b2 - 1, 1, t.c/prm[t.a2]*prm[i]));
		}
		ans = t.c;
	}
	printf("%lld\n", ans);
}

@version - 2@

#include<queue>
#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
const int MAXK = 800000;
struct node{
	node *ch[2];
	ll key, tag; int dis;
}pl[16000000 + 5], *rt1[128][64], *rt2[128][64], *tcnt, *NIL;
void pushdown(node *x) {
	if( x->tag != 1 ) {
		if( x->ch[0] != NIL ) {
			tcnt++; (*tcnt) = *(x->ch[0]);
			tcnt->tag *= x->tag, tcnt->key *= x->tag;
			x->ch[0] = tcnt;
		}
		if( x->ch[1] != NIL ) {
			tcnt++; (*tcnt) = *(x->ch[1]);
			tcnt->tag *= x->tag, tcnt->key *= x->tag;
			x->ch[1] = tcnt;
		}
		x->tag = 1;
	}
}
struct node2{
	node *x;
	node2(node *_x):x(_x){}
};
bool operator < (node2 a, node2 b) {
	return a.x->key < b.x->key;
}
node *newnode(ll x) {
	tcnt++;
	tcnt->ch[0] = tcnt->ch[1] = NIL;
	tcnt->key = x, tcnt->tag = 1, tcnt->dis = 1;
	return tcnt;
}
node *merge(node *x, node *y) {
	if( y == NIL ) return x;
	if( x == NIL ) return y;
	node *p = (++tcnt);
	if( x->key < y->key ) swap(x, y);
	(*p) = (*x); pushdown(p);
	p->ch[1] = merge(p->ch[1], y);
	if( p->ch[0]->dis < p->ch[1]->dis ) swap(p->ch[0], p->ch[1]);
	p->dis = p->ch[1]->dis + 1;
	return p;
}
void init() {
	NIL = tcnt = &pl[0];
	NIL->dis = 0;
	for(int i=0;i<64;i++)
		rt2[0][i] = NIL;
	for(int i=0;i<128;i++)
		rt2[i][0] = NIL;
}
bool is_prm(int n) {
	for(int i=2;i<n;i++)
		if( n % i == 0 ) return false;
	return true;
}
int prm[128], mxk[128], pcnt;
priority_queue<node2>que;
int main() {
	ll N; int K; init();
	scanf("%lld%d", &N, &K);
	for(int i=2;i<128;i++) {
		if( !is_prm(i) ) continue;
		prm[++pcnt] = i;
		for(ll nw=1;nw<=N/i;nw*=i) mxk[pcnt]++;
	}
	for(int i=1;i<=pcnt;i++)
		if( mxk[i] ) {
			rt1[i][1] = newnode(prm[i]), rt2[i][1] = merge(rt2[i-1][1], rt1[i][1]);
			for(int j=2;j<=mxk[i];j++) {
				rt1[i][j] = (++tcnt); (*rt1[i][j]) = (*rt2[i][j-1]);
				rt1[i][j]->key *= prm[i], rt1[i][j]->tag *= prm[i];
				rt2[i][j] = merge(rt2[i-1][j], rt1[i][j]);
			}
	/*for(node *i=&pl[1];i<=tcnt;i++)
		printf("%d %d %d %lld %lld\n", i-pl, i->ch[0]-pl, i->ch[1]-pl, i->key, i->tag);*/
		}
	for(int i=1;i<=pcnt;i++)
		for(int j=1;j<=mxk[i];j++)
			que.push(rt1[i][j]);
	ll ans;
	for(int i=1;i<=K;i++) {
		node2 f = que.top(); que.pop();
		pushdown(f.x);
		que.push(node2(merge(f.x->ch[0], f.x->ch[1])));
		ans = f.x->key;
	}
	printf("%lld\n", ans);
}

@details@

一开始我在合并的时候，某一个结点等于 NIL 的时候新建了一个结点来存另一个结点。

但是极限数据始终不是 RE 就是 MLE。

后来我选择直接返回另一个结点，然后就没问题了。

连这个空间也要卡吗……