# meaning of the title

If the prime factorization of an integer M greater than 1 has k prime numbers, the same can be counted as many. The largest prime factor is Ak, and akk < = N, Ak < 128 is satisfied, we call the integer M as N-pseudosmooth number. Now, let's give N and find the N-pseudosmooth number of K in all integers.
2 ≤ N ≤ 10 ^ 18, 1 ≤ K ≤ 800000, to ensure that at least k numbers meet the requirements

# Analysis

It's a very powerful question. It seems that Lord lyc has a more concise approach, but he doesn't understand it.
My% is the master's Title Solution.
It is assumed that f[i,j] represents a set composed of all the numbers of j prime numbers after decomposition, g[i,j] represents a set composed of all the numbers of j prime numbers after decomposition, that is, the prefix sum of f[i,j].
Obviously
f[i,j]=∑g[i−1,j−k]∗pki
g[i,j]=g[i−1,j]+f[i,j]
Here addition represents the union of a set, and multiplication represents the multiplication of each number in a set by a constant.
Obviously, these operations can be implemented with my big parallel heap, as long as the parallel heap can be persisted.

# Code

```#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;
}```

Posted by elecktricity on Fri, 01 May 2020 08:20:54 -0700