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=200010;
      mo=1000000007;

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

var a,sum,h,loc,num:arr;
    b:array[0..30] of int64;
    f:array[0..20,0..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 1];
    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:=1;
    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*7;
          end;
          k:=k*5;
        end;
        j:=j*3;
      end;
      i:=i*2;
    end;
    sort(1,m,a);
  end;

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

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

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

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

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