bzoj3131

这是一道很好也很烦的综合题……

首先我们肯定要先把f(i)处理出来这是毫无疑问的

我们要求出数位乘积为now的个数，首先是空间上的问题

直接肯定会爆空间，不难发现

乘积的质因数只有2，3，5，7，并且指数也不是特别大

暴力可得到不同的乘积最多只有15000不到

然后我们就可以对其离散化然后数位dp

dp完之后，对于点(p,q),这上面的金子个数是sum(p)*sum(q)个 （sum表示数位乘积为p的数的个数）

然后我们要求金子前k多的点，当状态太多无法算出所有状态求最优值时，我们常常用堆来维护

首先我们对sum排序（假定降序），对于每个乘积x，设乘积x离散化后对应的编号为w(x)

在x行上金子最多的点一定是sum[w(x)]*sum[1],次大的点一定是sum[w(x)]*sum[2]……

然后我们对当前这n行上最多的点维护一个大根堆

当我们每次将堆顶的点取出时，堆顶所在行的下一大的点可能是之后选取结果产生影响，

因此我们要将这行下一大的点加入堆，一共只要弹k次，所以复杂度为O(klogt)

 const maxn=;
       mo=;

 type arr=array[..maxn] of int64;

 var a,sum,h,loc,num:arr;
     b:array[..] of int64;
     f:array[..,..maxn] of int64;
     n,ans,x:int64;
     c,m,t,i:longint;

 procedure swap(var a,b:int64);
   var c:int64;
   begin
     c:=a;
     a:=b;
     b:=c;
   end;

 procedure sort(l,r:longint;var a:arr);
   var i,j:longint;x,y:int64;
   begin
     i:=l;
     j:=r;
     x:=a[(l+r) shr ];
     repeat
       while a[i]<x do inc(i);
       while x<a[j] do dec(j);
       if i<=j then
       begin
         swap(a[i],a[j]);
         inc(i);
         dec(j);
       end;
     until i>j;
     if i<r then sort(i,r,a);
     if j>l then sort(l,j,a);
   end;

 procedure prepare;
   var i,j,k,l:int64;
   begin
     i:=;
     while i<=n do
     begin
       j:=i;
       while j<=n do
       begin
         k:=j;
         while k<=n do
         begin
           l:=k;
           while l<=n do
           begin
             inc(m);
             a[m]:=l;
             l:=l*;
           end;
           k:=k*;
         end;
         j:=j*;
       end;
       i:=i*;
     end;
     sort(,m,a);
   end;

 procedure work;
   begin
     t:=;
     x:=n;
     while x<> do
     begin
       inc(t);
       b[t]:=x mod ;
       x:=x div ;
     end;
   end;

 function find(l,r:longint;x:int64):longint;
   var mid:longint;
   begin
     while l<r do
     begin
       mid:=(l+r)shr ;
       if a[mid]=x then exit(mid);
       if a[mid]<x then l:=mid+ else r:=mid-;
     end;
     if a[l]=x then exit(l);
     exit();
   end;

 procedure count;
   var i,j,k:longint;
       now,y:int64;
   begin
     work;
     f[][]:=;  //f[i,j]表示到第i位，乘积为j（j是离散化后的排名）的方案数
     for i:= to t- do
       for j:= to m do
         for k:= to  do
           if (a[j] mod k=) then
             f[i,j]:=f[i,j]+f[i-,find(,j,a[j] div k)];

     now:=;
     for i:=t downto  do
     begin
       for j:= to b[i]- do  //肯定不可能是0
         for k:= to m do
           if (a[k]>=now*j) and ((a[k] div now) mod j=) and (a[k] mod now=) then
             sum[k]:=sum[k]+f[i-,find(,k,a[k] div (now*j))];
       now:=now*b[i];
       if now= then break;
     end;
     if now<> then inc(sum[find(,m,now)]);
     for i:= to m do
       for j:= to t- do
         sum[i]:=sum[i]+f[j,i];
   end;

 procedure sift(i,n:longint);
   var j:longint;
       x:int64;
   begin
     x:=h[i];
     j:=i shl ;
     while j<=n do
     begin
       if (j<n) and (h[j]<h[j+]) then inc(j);
       if x>=h[j] then exit
       else begin
         swap(h[i],h[j]);
         swap(loc[i],loc[j]);
         swap(num[i],num[j]);
         i:=j;
         j:=j shl ;
       end;
     end;
   end;

 begin
   readln(n,c);
   prepare;
   work;
   count;
   sort(,m,sum);  //为了统一形式，这里是升序
   for i:= to m do
   begin
     h[i]:=sum[i]*sum[m];  //当前第i行上最大的点
     loc[i]:=m;  
     num[i]:=i;  //所代表的行
   end;
   for i:=m downto  do
     sift(i,m);
   ans:=;
   for i:= to c do
   begin
     ans:=(ans+(h[] mod mo)) mod mo;
     dec(loc[]);  //加入这行下一大的点
     h[]:=sum[num[]]*sum[loc[]];
     sift(,m);
   end;
   writeln(ans);
 end.