【贪心】[51Nod1982] 阶乘！

Description

给出一个n个数的序列A
你需要将

$$\prod\limits_{i=0}^{n}A_i!$$
表示为
$$t\times\prod\limits_{i=0}^{k}(B_i!)^{e_i}$$
的形式

其中t的值我们不关心
需要做的是使序列$B_1,e_1,B_2,e_2...$的字典序最大

输出这个字典序最大的序列
$n,A\leq 100000$

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]);
}