Description
给出一个n个数的序列A
你需要将
表示为
的形式
其中t的值我们不关心
需要做的是使序列
的字典序最大
输出这个字典序最大的序列
Solution
由于大于100000的第一个质数是100003
我们需要从100002倒过来枚举B
可以先用线筛一类的东西将每个数的质因数分解预处理出来
阶乘的也可以弄出来
我们可以维护一个小根堆,每个元素代表一个质数,它的键值为它当前有的个数除以它当前需要的个数
每次判断堆顶,如果键值大于等于1那么当前的B就加入答案
然后此时整个堆所有数的键值减去一个常数(并不需要重构堆),因此复杂度是线性的
每次做完一个B到B-1的时候暴力更改B的质因子的需要的个数,把这些元素在堆中相应修改
因为小于100002的数不同质因子最多只有6个
如果你不想手打堆想偷懒用set的话,在减常数那里要稍微奇技淫巧一下
Code
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <set>
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fod(i,a,b) for(int i=a;i>=b;i--)
#define N 100005
#define LL long long
using namespace std;
int n,a[N],pc[N][10][2],le[N],pr[N],l,r,ans[N][2],s;
LL vl[N],v1[N],ct[N],vk[N];
bool bz[N];
struct node
{
LL p;
node(LL _p=0):p(_p){};
friend bool operator <(node x,node y)
{
return (vl[x.p]*v1[y.p]<vl[y.p]*v1[x.p])||(vl[x.p]*v1[y.p]==vl[y.p]*v1[x.p]&&x.p<y.p);
}
};
set<node> h;
void prp()
{
r=N-3;
fo(i,2,r)
{
if(!bz[i]) le[i]=1,pc[i][1][0]=i,pc[i][1][1]=1,pr[++l]=i;
for(int j=1;j<=l&&i*pr[j]<=r;j++)
{
int q=i*pr[j];
bz[q]=1;
le[q]=le[i];
int mw=0;
fo(p,1,le[i]) pc[q][p][0]=pc[i][p][0],pc[q][p][1]=pc[i][p][1],mw=(pc[i][p][0]==pr[j])?p:mw;
if(i%pr[j]==0) {pc[q][mw][1]++;break;}
pc[q][++le[q]][0]=pr[j],pc[q][le[q]][1]=1;
}
}
}
int main()
{
cin>>n;
prp();
fo(i,1,n) scanf("%d",&a[i]),ct[a[i]]++;
fod(i,r,1)
{
ct[i]+=ct[i+1];
fo(j,1,le[i])
{
vl[pc[i][j][0]]+=pc[i][j][1]*ct[i];
v1[pc[i][j][0]]+=pc[i][j][1];
}
}
fo(i,1,l) h.insert(node(pr[i])),vk[pr[i]]=vl[pr[i]];
LL le1=0;
fod(i,r,2)
{
if(h.empty()) break;
node p=*h.begin();
while(p.p>i) h.erase(h.begin()),p=*h.begin();
if(vl[p.p]>=v1[p.p])
{
ans[++s][0]=i,ans[s][1]=vl[p.p]/v1[p.p];
le1+=ans[s][1];
fo(j,1,l)
{
if(pr[j]>i) break;
if(v1[pr[j]]>0)
{
vl[pr[j]]-=v1[pr[j]]*ans[s][1];
}
}
}
fo(j,1,le[i])
{
int t=pc[i][j][0],v=pc[i][j][1];
h.erase(h.find(node(t)));
v1[t]-=v;
vk[t]=vl[t];
if(v1[t]>0) h.insert(node(t));
}
}
printf("%d\n",s);
fo(i,1,s) printf("%d %d\n",ans[i][0],ans[i][1]);
}