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

---

＠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。可以把这个状态看作 \([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
#include
#include
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;ique;
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

@version - 2@

#include
#include
#include
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;ique;
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。
后来我选择直接返回另一个结点，然后就没问题了。

连这个空间也要卡吗……

转载于:https://www.cnblogs.com/Tiw-Air-OAO/p/10287082.html