数位DP-HDU-3652-B-number

B-number

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 3537 Accepted Submission(s): 1992

Problem Description
A wqb-number, or B-number for short, is a non-negative integer whose decimal form contains the sub- string “13” and can be divided by 13. For example, 130 and 2613 are wqb-numbers, but 143 and 2639 are not. Your task is to calculate how many wqb-numbers from 1 to n for a given integer n.

Input
Process till EOF. In each line, there is one positive integer n(1 <= n <= 1000000000).

Output
Print each answer in a single line.

Sample Input
13
100
200
1000

Sample Output
1
1
2
2

Author
wqb0039

Source
2010 Asia Regional Chengdu Site —— Online Contest

题意：
给定一个数n，要求1到n的所有满足以下条件的数的个数：
1、这个数能被13整除；
2、这个数的数位有连续的13。
例如：13、130、2613。

首先，根据题中要求来确定状态，我们仍然以位数size为第一个参数，开头数字head为第二个参数，那么还需要确定是否含有连续13以及整除13的情况，所以第三个参数代表是否含有13，而第四个参数代表除以13的余数。
那么dp[size][head][have][mod]就出来了，利用记忆化搜索便能求解。
dfs过程：
先定义temp=(13+mod-head*10^(size-1)%13)%13，这是剩下位应有的余数。
如果have为1时，说明要求有13，那么依次加dp[size-1][0~9][1][temp]，如果head为1，再额外加一个dp[size-1][3][0][temp]，原因是此时这两位构成了13。
如果have为0，说明要求没有13，那么如果head为1，依次加dp[size-1][0~2,4~9][0][temp]；如果temp不为1，再额外加上一个dp[size-1][3][0][temp]。
记忆化搜索就这么推便可。
对于一个数n，仍是先放进num[size]，然后从最高位开始统计到最低位。
我们需要记录的有：当前位之前是否出现连续13，当前位之前的数位的余数。
对于第i位，首先确定之前的位是否含有13。如果有，那么就把符合余数条件的有13和没有13的数（have值任意）的个数都加上；如果没有，就只加有13（have值为1）的。
最后附上代码。

//
// main.cpp
// 数位DP-G-B-number
//
// Created by 袁子涵 on 15/11/14.
// Copyright © 2015年 袁子涵. All rights reserved.
//
// 0ms 1612KB

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <algorithm>

using namespace std;

long long int dp[12][10][2][13];

long long int p(int n)
{
    long long int out=1;
    while (n) {
        out*=10;
        n--;
    }
    return out;
}

long long int dfs(int size,int head,int have,int mod)
{
    if (dp[size][head][have][mod]!=-1) {
        return dp[size][head][have][mod];
    }
    long long int bit=p(size-1);
    int temp=(13+mod-head*bit%13)%13;
    dp[size][head][have][mod]=0;
    for (int i=0; i<10; i++) {
        if (have) {
            dp[size][head][have][mod]+=dfs(size-1, i, 1, temp);
            if (head==1 && i==3) {
                dp[size][head][have][mod]+=dfs(size-1, i, 0, temp);
            }
        }
        else
        {
            if (head==1 && i==3) {
                continue;
            }
            else
                dp[size][head][have][mod]+=dfs(size-1, i, 0, temp);
        }
    }
    return dp[size][head][have][mod];
}

long long int solve(long long int n)
{
    int num[12],l=0,flag=0,mod=0;
    long long int sum=0;
    memset(num, 0, sizeof(num));
    while (n) {
        num[++l]=n%10;
        n/=10;
    }
    for (int i=l; i>0; i--) {
        for (int j=0; j<num[i]; j++) {
            if (flag || (j==3 && num[i+1]==1)) {
                sum+=dfs(i, j, 1, (13-mod*p(i)%13)%13);
                sum+=dfs(i, j, 0, (13-mod*p(i)%13)%13);
            }
            else
                sum+=dfs(i, j, 1, (13-mod*p(i)%13)%13);
        }
        if (num[i+1]==1 && num[i]==3) {
            flag=1;
        }
        mod=(mod*10+num[i])%13;
    }
    return sum;
}

int main(int argc, const char * argv[]) {
    long long int n;
    memset(dp, -1, sizeof(dp));
    for (int i=0; i<10; i++) {
        for (int j=0; j<=12; j++) {
            dp[1][i][1][j]=0;
            dp[1][i][0][j]=0;
        }
        dp[1][i][0][i]=1;
    }
    dp[2][1][1][0]=1;
    while (scanf("%lld",&n)!=EOF) {
        cout << solve(n+1) << endl;
    }
    return 0;
}