bzoj 4524: [Cqoi2016]伪光滑数 可持久化可并堆+动态规划

题意

若一个大于1的整数M的质因数分解有k个素数，相同的也算多个，其最大的质因子为$A_k$，并且满足$A_k^K<=N,A_k<128$，我们就称整数M为N-伪光滑数。现在给出N，求所有整数中，第K大的N-伪光滑数。
2 ≤ N ≤ 10^18， 1 ≤ K ≤ 800000，保证至少有 K 个满足要求的数

分析

十分牛逼的题。貌似lyc大爷有更简洁的做法，然而并没有看懂。
我%的是这位大爷的题解。
大概就是设f[i,j]表示满足最大素数为p[i]，分解后有j个素数的所有数组成的集合，g[i,j]表示满足用前i个素数，分解后有j个素数的所有数组成的集合，也就是f[i,j]的前缀和。
显然有
$f[i,j]=\sum g[i-1,j-k]*p_i^k$
$g[i,j]=g[i-1,j]+f[i,j]$
这里加法表示集合求并，乘法表示集合中每个数乘上一个常数。
显然这些操作都可以用我大可并堆来实现，只要把可并堆可持久化一下就好了。

代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;

typedef long long LL;

int k,prime[50],tot,sz,f[50][105],g[50][105];
bool vis[130];
LL n;
struct heap{int l,r,dis;LL tag,val;}t[17000005];
priority_queue<pair<LL,pair<int,int> > > que;

void get_prime()
{
    for (int i=2;i<128;i++)
        if (!vis[i])
        {
            vis[i]=1;prime[++tot]=i;
            for (int j=i*2;j<128;j+=i) vis[j]=1;
        }
}

int newnode(int x,LL tag)
{
    sz++;t[sz]=t[x];
    t[sz].tag*=tag;t[sz].val*=tag;
    return sz;
}

void pushdown(int d)
{
    if (t[d].tag==1) return;
    LL w=t[d].tag;t[d].tag=1;
    if (t[d].l) t[d].l=newnode(t[d].l,w);
    if (t[d].r) t[d].r=newnode(t[d].r,w);
}

int merge(int x,int y)
{
    if (!x||!y) return x+y;
    pushdown(x);pushdown(y);
    if (t[x].val<t[y].val) swap(x,y);
    int v=newnode(x,1);t[v].r=merge(t[v].r,y);
    if (t[t[v].l].dis<t[t[v].r].dis) swap(t[v].l,t[v].r);
    t[v].dis=t[t[v].l].dis+1;
    return v;
}

void prework()
{
    get_prime();
    g[0][0]=++sz;t[sz].tag=t[sz].val=1;
    for (int i=1;i<=tot;i++)
    {
        g[i][0]=1;
        for (LL j=1,pr=prime[i];pr>0&&pr<=n;pr*=prime[i],j++)
        {
            for (LL k=1,pri=prime[i];k<=j;k++,pri*=prime[i]) f[i][j]=merge(f[i][j],newnode(g[i-1][j-k],pri));
            g[i][j]=merge(g[i-1][j],f[i][j]);
            que.push(make_pair(t[f[i][j]].val,make_pair(i,j)));
        }
    }
}

void solve()
{
    LL ans;
    while (k--)
    {
        ans=que.top().first;int i=que.top().second.first,j=que.top().second.second;que.pop();
        pushdown(f[i][j]);f[i][j]=merge(t[f[i][j]].l,t[f[i][j]].r);
        que.push(make_pair(t[f[i][j]].val,make_pair(i,j)));
    }
    printf("%lld",ans);
}

int main()
{
    scanf("%lld%d",&n,&k);
    prework();
    solve();
    return 0;
}