BZOJ4524 [CQOI2016]伪光滑数 可持久化可并堆+DP

很有意思的一个题

考场上我竟然乱搞出这种奇怪的以前想都没想过的算法（以前根本想不到函数式数据结构还可以拿来DP）

其实写这个题解我也是不想这个有趣的方法就这么绝迹了呢。。。

因为是求第K大所以不难想到用堆的K路归并问题，对答案的种类我们分类，最直观的分类就是按最大因子和分解项数来分类

即用f[i,j]表示最大质因子为p[i]，用了j项分解数的数的集合，因为要求数的不重不漏，我们力求让所有的数都由互素的小数集合扩展得到，为了获得之前所有的数，我们保存g[i,j]为f[i,j]的前缀和，意为前i种素因子的所有数集，不难得到DP方程：



其中加号是集合的并，只要这些集合可以归并、求最大值，就可以在外层用堆维护每个集合的最大值，每次取最大的一个，删除最大值，还可以对集合进行乘法，而这一些需求均满足可并堆的性质，因此我们用可持久化可并堆来作为数值，进行DP。

可并堆的乘法用标记实现，标记下传时新建节点即可。注意中间过程可能爆long long，乘法要判>0防炸。

#include<queue>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long LL;
struct node{
int i,k;LL v;
node(int a,int b,LL c){i=a;k=b;v=c;}
bool operator<(node b)const{return v<b.v;}
};
priority_queue<node>q;
struct Heap{LL v,tg;int l,r;}c[16000005];
LL N;
int K,tot=0,p[505],vst[505],f[505][505],g[505][505];
int NewNode(int x,LL tg){
if(x==0)return 0;
tot++;c[tot]=c[x];c[tot].v*=tg;c[tot].tg*=tg;
return tot;
}
void Pushdown(int x){
if(c[x].tg!=1){
c[x].l=NewNode(c[x].l,c[x].tg);
c[x].r=NewNode(c[x].r,c[x].tg);
c[x].tg=1;
}
}
int merge(int x,int y){
if(!x||!y)return x+y;
Pushdown(x);Pushdown(y);
if(c[x].v<c[y].v)swap(x,y);
int z=++tot;c[z]=c[x];
c[z].l=merge(c[x].r,y);
c[z].r=c[x].l;c[z].tg=1;
return z;
}
void init(){
int i,j,k;LL pr,prm;
scanf("%lld%d",&N,&K);
for(i=2;i<=128;i++)
if(!vst[i]){
p[++p[0]]=i;
for(j=i+i;j<=128;j+=i)vst[j]=1;
}
f[0][0]=1;tot=1;g[0][0]=1;
c[f[0][0]].v=c[f[0][0]].tg=1;
for(i=1;i<=p[0];i++){
f[i][0]=f[0][0];g[i][0]=1;
for(pr=p[i],j=1;pr>0&&pr<=N;j++,pr=pr*p[i]){
f[i][j]=0;
for(prm=p[i],k=1;k<=j;k++,prm*=p[i])
f[i][j]=merge(f[i][j],NewNode(g[i-1][j-k],prm));
q.push(node(i,j,c[f[i][j]].v));
g[i][j]=merge(g[i-1][j],f[i][j]);
}
}
}
void solve(){
int i,j;
for(i=1;i<=K;i++){
node x=q.top();q.pop();
if(i==K){
printf("%lld\n",x.v);
return;
}
Pushdown(f[x.i][x.k]);
f[x.i][x.k]=merge(c[f[x.i][x.k]].l,c[f[x.i][x.k]].r);
q.push(node(x.i,x.k,c[f[x.i][x.k]].v));
}
}
int main(){
init();
solve();
return 0;
}