数位DP总结

数位DP=区间求符合条件的数的个数的算法=数很大，无法直接暴力的算法≈让人苦恼愤怒，依然D不出来的勾魂算法

数位DP的两种写法：

1、递推

 结构：

init()函数，根据递推数位的公式求得的满足某长度的符合数的个数

cal()函数，假设要计算的数字为n，数位长度为len。1到len-1长度累加，len长度的拿出来一个位置一个位置遍历判定再累加。

输出cal(right+1)-cal（left)，right为区间最右，left为区间最左

 

模板：

int f[35][35],digit[35];

void Init()

{

    int i,j;

    /*递推关系式，请忽略

    f[0][0]=1;

    for(i=1; i<32; ++i)

    {

        f[i][0]=f[i-1][0];

        for(j=1; j<=i; ++j)

            f[i][j]=f[i-1][j]+f[i-1][j-1]; 

    }

    */

}



int Cal(int x,int k,int b) 

{

    int tot=0,len=0,ans=0,i;

    while(x) //初始化数位

    {

        digit[++len]=x%b;

        x/=b;

    }

    for(i=len;i&&tot<=k;--i) //分长度累加

    {

      /*判断累加，请忽略

      if(digit[i]>1)  

      {

          ans+=f[i][k-tot];break;

      }

      if(digit[i]==1) 

      {

          ans+=f[i-1][k-tot];

          tot++;

      }

      */

    }

    return ans;

}

输出Cal(right+1)-Cal（left)

 

2、递归（记忆化搜索，据说记忆化搜索最优）

个人觉得记忆化搜索更简单，因为它的结构简单。dp数组d的是pos前面数组的状态。

结构：

dfs()函数，记忆化搜索符合条件的数的个数。记忆化搜索的参数无非是表示上一状态或者是下一状态的。

cal()函数，初始化数位，调用dfs函数。

输出cal(right)-cal(left-1)

 

模板：

int dfs(int pos , int pre , int have , bool doing) //doing为边界，pos为计算到当前第几位

{

    if(pos == -1)

        return have == 2 && pre == 0;



    if(!doing && dp[pos][pre][have] != -1) //若不是统计边界位，则直接返回记忆下的数

        return dp[pos][pre][have];



    int ans = 0;

    int end = doing ? digit[pos] : 9; 

    for(int i = 0 ; i <= end ; i ++)

    {

       /*初始化下一层dfs的参数,请忽略 

        int npre = (pre*10 + i) % 13; 

        int nhave = have;

        if(have == 0 && i == 1)

            nhave = 1;

        else if(have == 1 && i != 1)

            nhave = 0;

        if(have == 1 && i == 3)

            nhave = 2;

        */

        ans += dfs(pos-1 , npre , nhave , doing && i == end ); //doing在i==end的时候会是1

    }



    if(!doing)

        dp[pos][pre][have] = ans;

    return ans;

}





int cal(int x)

{

    int pos = 0;

    while(x)

    {

        digit[pos++] = x % 10;

        x /= 10;

    }

    return dfs(pos - 1 , 0 , 0 , 1);

}
输出Cal(right)-Cal(left-1)