P3303 [SDOI2013]淘金

题目描述

小Z在玩一个叫做《淘金者》的游戏。游戏的世界是一个二维坐标。X轴、Y轴坐标范围均为1..N。初始的时候，所有的整数坐标点上均有一块金子，共N*N块。

一阵风吹过，金子的位置发生了一些变化。细心的小Z发现，初始在(i，j)坐标处的金子会变到(f(i)，fIj))坐标处。其中f(x)表示x各位数字的乘积，例如f(99)=81，f(12)=2，f(10)=0。

如果金子变化后的坐标不在1..N的范围内，我们认为这块金子已经被移出游戏。同时可以发现，对于变化之后的游戏局面，某些坐标上的金子数量可能不止一块，而另外一些坐标上可能已经没有金子。这次变化之后，游戏将不会再对金子的位置和数量进行改变，玩家可以开始进行采集工作。

小Z很懒，打算只进行K次采集。每次采集可以得到某一个坐标上的所有金子，采集之后，该坐标上的金子数变为0。

现在小Z希望知道，对于变化之后的游戏局面，在采集次数为K的前提下，最多可以采集到多少块金子？ 答案可能很大，小Z希望得到对1000000007(10^9+7)取模之后的答案。

输入格式

共一行，包含两个正整数N，K。

输出格式

一个整数，表示最多可以采集到的金子数量。

说明/提示

N < = 10^12 ,K < = 100000

对于100%的测试数据：K < = N^2

首先很容易就能想到，我们要求的是对于f(i)=x中的每一个x，能到达它的i有多少个，把它记作c(x)（代码里是数组g），即到达某个终值的初值数量。

然后我就卡住了，我想要不要枚举每一个终值x，并算出c(x)。但是一看n的范围，又觉得不可做。

后来瞅了一眼题解才发现，每个个位数一定可以拆成2^p1*3^p2*5^p3*7^p4。那么既然终值是一个一个个位数的乘积，它所含有的最大质因子不会超过7。终值的数量就大大减少了，可以dfs乘上2、3、5、7四个因子得出，即枚举四个因子的指数。

然后我的大体思路就没有错了，对于每一个终值x，跑一遍数位DP——我只会写记搜，来找到能到达它的初值数量。这里采用分解出每个终值2、3、5、7因子的个数，然后在记搜里通过枚举每一位数的时候减去对应2、3、5、7个数的方法，枚举完每一位如果四种因子的指数都减到0说明是一个可行的数字，返回1。

最后因为我们要求的是c(x)值两两乘积（x、y坐标）的前k大个，所以和这些c值具体属于谁没有关系了，直接从大到小排一遍序。在优先队列里扔二元组，二元组存是哪两个c值（即数组下标），优先队列以两个c值的乘积排序。由于下标为1的c值是最大的，而又不可能枚举所有c值相乘，所以一开始让每一个c值和c(1)组成二元组，这样对于前面的那个c值来说一定是最大的。从优先队列里取k次，每一次取出之后把二元组第二个下标+1再丢回去，表示二元组第一个下标的c值和第二个下标的下一个c值相乘。

然后要注意记搜的时候的前导0，数组不要开小，long long以及优先队列里二元组下标不要越界，具体都标注在代码里了。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const long long mod=1000000007;
long long n,k,cnt,g[20010],v[20010],ans;
struct node{
    long long x,y;
    friend bool operator < (node n1,node n2){
        return (long long)g[n1.x]*g[n1.y] < (long long)g[n2.x]*g[n2.y];
    }
};
priority_queue<node>q;
long long len[15],lens;
long long h[5]={0,2,3,5,7};
long long num[10][5]={
    {0,0,0,0,0},//0
    {0,0,0,0,0},//1
    {0,1,0,0,0},//2
    {0,0,1,0,0},//3
    {0,2,0,0,0},//4
    {0,0,0,1,0},//5
    {0,1,1,0,0},//6
    {0,0,0,0,1},//7
    {0,3,0,0,0},//8
    {0,0,2,0,0},//9
};
bool cmp(long long x,long long y){
    if(x>y)return true;
    else return false;
}
long long f[17][41][29][17][17][2];//数组要开够——不要担心空间—— 
long long dfs(long long pos,long long limit,long long num2,long long num3,long long num5,long long num7,int iszero){//要关注前导0 
    if(num2<0||num3<0||num5<0||num7<0)return 0;
    if(pos<=0){
        if(!num2&&!num3&&!num5&&!num7)return 1;
        else return 0;
    }
    if(!limit&&f[pos][num2][num3][num5][num7][iszero]!=-1)return f[pos][num2][num3][num5][num7][iszero];
    long long upp=(limit?len[pos]:9);
    long long val=0;
    for(int i=(pos>1?0:1);i<=upp;i++){
        if(!iszero&&!i)continue;//关注前导0的原因就是这里：如果现在已经不是前导0了但这一位是0，乘出来一定是0 
        val+=dfs(pos-1,limit&&i==upp,num2-num[i][1],num3-num[i][2],num5-num[i][3],num7-num[i][4],iszero&&i==0);
    }
    if(!limit)f[pos][num2][num3][num5][num7][iszero]=val;
    return val;
}
void make(long long pos,long long num){//这里也要开long long呀！指num 
    if(num>n)return;
    v[++cnt]=num;
    for(long long i=pos;i<=4;i++){//从pos开始，枚举完一种因子就不再枚举它本身了【避免重复】 
        make(i,num*h[i]);
    }
}
long long solve(long long x){
    long long is2,is3,is5,is7;
    is2=is3=is5=is7=0;
    while(x%2==0){
        x/=2;
        is2++;
    }
    while(x%3==0){
        x/=3;
        is3++;
    }
    while(x%5==0){
        x/=5;
        is5++;
    }
    while(x%7==0){
        x/=7;
        is7++;
    }
    return dfs(lens,1,is2,is3,is5,is7,1);
}
int main()
{
    scanf("%lld%lld",&n,&k);
    make(1,1);//枚举出1-N可能的终值 
    lens=0;
    while(n){
        len[++lens]=n%10;
        n/=10;
    }
    memset(f,-1,sizeof(f));
    for(long long i=1;i<=cnt;i++)g[i]=solve(v[i]);//为每个终值找出能到达它的数字个数 
    sort(g+1,g+cnt+1,cmp);
    node p;
    for(long long i=1;i<=cnt;i++){//因为排过序了，所以下标为1的是最大的 
        p.x=i,p.y=1;
        q.push(p);
    }
    while(k--){
        node u=q.top();
        q.pop();
        ans=(ans+g[u.x]*g[u.y])%mod;
        u.y++;//往较小的推 
        if(u.y>cnt)continue;//注意如果乘完了所有数量就不再往小的推了 
        q.push(u);
    }
    printf("%lld",ans);
    return 0;
}

思考一下午调码一晚上，不开long long…数组开小…