数位dp题集

题集见大佬博客

不要62

入门题，检验刚才自己有没有看懂

注意一些细节。

的确挺套路的

#include<bits/stdc++.h>
#define REP(i, a, b) for(register int i = (a); i < (b); i++)
#define _for(i, a, b) for(register int i = (a); i <= (b); i++)
using namespace std;

const int MAXN = ;
int a[MAXN], dp[MAXN][MAXN][MAXN], len; //dp数组记录除了lead和limit以外其他的东西 

int dfs(int pos, int pre, int lead, int sum, int limit)
{
    if(pos > len) return sum;
    if(dp[pos][pre][sum] != - && !limit && !lead) return dp[pos][pre][sum]; //记忆化的时候记得limit和lead
    int l = limit ? a[len-pos+] : , res = ; //注意是倒序存的，所以是len-pos+1
    _for(i, , l)
    {
        if(!i && lead) res += dfs(pos + , pre, lead, sum, limit && (i == l)); //先看是不是前导0
        else if(i && lead) res += dfs(pos + , i, , sum | (i == ), limit && (i == l)); //看是不是第一位
        else res += dfs(pos + , i, , sum | (i == ) | (pre ==  && i == ), limit && (i == l)); //正式处理
    }
    return (!limit && !lead) ? dp[pos][pre][sum] = res : res; //记忆化的时候记得limit和lead
}

int part(int x)
{
    if(x < ) return ; //0的处理
    memset(dp, -, sizeof(dp));
    len = ; int t = x;
    for(; x; x /= ) a[++len] = x % ;
    return t - dfs(, , , , );
}

int main()
{
    int n, m;
    while(scanf("%d%d", &n, &m))
    {
        if(n ==  && m == ) break;
        printf("%d\n", part(m) - part(n - ));
    }
    return ;
}

P2657 [SCOI2009]windy数

继续套路

#include<bits/stdc++.h>
#define REP(i, a, b) for(register int i = (a); i < (b); i++)
#define _for(i, a, b) for(register int i = (a); i <= (b); i++)
using namespace std;

const int MAXN = ;
int a[MAXN], dp[MAXN][MAXN][MAXN], len;

int dfs(int pos, int pre, int ans, int lead, int limit)
{
    if(pos > len) return ans;
    if(dp[pos][pre][ans] != - && (!limit && !lead)) return dp[pos][pre][ans];
    int l = limit ? a[len-pos+] : , res = ;
    _for(i, , l)
    {
        if(!i && lead) res += dfs(pos + , pre, ans, lead, limit & (i == l));
        else if(i && lead) res += dfs(pos + , i, ans, , limit & (i == l));
        else res += dfs(pos + , i, ans & (abs(i - pre) >= ), , limit & (i == l));
    }
    return (!limit && !lead) ? dp[pos][pre][ans] = res : res;
}

int part(int x)
{
    if(x == ) return ;
    memset(dp, -, sizeof(dp));
    len = ;
    for(; x; x /= ) a[++len] = x % ;
    return dfs(, , , , );
}

int main()
{
    int a, b;
    scanf("%d%d", &a, &b);
    printf("%d\n", part(b) - part(a - ));
    return ;
}

P2602 [ZJOI2010]数字计数

第一次这么轻松做出紫题

一样套模板，爽啊

#include<bits/stdc++.h>
#define REP(i, a, b) for(register int i = (a); i < (b); i++)
#define _for(i, a, b) for(register int i = (a); i <= (b); i++)
using namespace std;

typedef long long ll;
const int MAXN = ;
const int MAXM = 1e6 + ;
ll dp[MAXN][MAXN];
int a[MAXN], len;

ll dfs(int pos, int ans, int lead, int limit, int key)
{
    if(pos > len) return ans;
    if(dp[pos][ans] != - && (!lead && !limit)) return dp[pos][ans];
    int l = limit ? a[len-pos+] : ; ll res = ;
    _for(i, , l)
    {
        if(!i && lead) res += dfs(pos + , ans, lead, limit && (i == l), key);
        else res += dfs(pos + , ans + (i == key), , limit && (i == l), key);
    }
    return (!lead && !limit) ? dp[pos][ans] = res : res;
}

ll part(ll x, int i)
{
    memset(dp, -, sizeof(dp));
    len = ;
    for(; x > ; x /= ) a[++len] = x % ;
    return dfs(, , , , i);
}

inline ll work(ll a, ll b, int i)
{
    return a ? part(b, i) - part(a - , i) : part(b, i) - part(a, i) + (i == );
}

int main()
{
    ll a, b;
    scanf("%lld%lld", &a, &b);
    _for(i, , )
        printf("%lld%c", work(a, b, i), i ==  ? '\n' : ' ');
    return ;
}

P3413 SAC#1 - 萌数

注意数字很大，要用字符串存储

然后就没啥了，又独立做出紫题

#include<bits/stdc++.h>
#define add(a, b) a = (a + b) % mod
#define REP(i, a, b) for(register int i = (a); i < (b); i++)
#define _for(i, a, b) for(register int i = (a); i <= (b); i++)
using namespace std;

const int MAXN = ;
const int MAXM = 1e3 + ;
const int mod = 1e9 + ;

int dp[MAXM][MAXN][MAXN][];
int a[MAXM], len;
char s1[MAXM], s2[MAXM];

int dfs(int pos, int pre, int ppre, int ans, int lead, int limit)
{
    if(pos > len) return ans;
    if(dp[pos][pre][ppre][ans] != - && (!lead && !limit)) return dp[pos][pre][ppre][ans];
    int l = limit ? a[len-pos+] : ; int res = ;
    _for(i, , l)
    {
        if(!i && lead) add(res, dfs(pos + , pre, ppre, ans, lead, limit && (i == l)));
        else if(i && lead) add(res, dfs(pos + , i, pre, ans, , limit && (i == l)));
        else add(res, dfs(pos + , i, pre, ans | (i == pre) | (i == ppre), , limit && (i == l)));
    }
    return (!lead && !limit) ? dp[pos][pre][ppre][ans] = res : res;
}

int part(char* s)
{
    memset(dp, -, sizeof(dp));
    len = strlen(s + );
    _for(i, , len) a[i] = s[len - i + ] - '';
    return dfs(, -, -, , , );
}

int judge(char* s)
{
    _for(i, , strlen(s + ))
        if(s[i] == s[i-] || s[i] == s[i-])
            return ;
    return ;
}

int main()
{
    scanf("%s%s", s1 + , s2 + );
    if(s1[] ==  && strlen(s1 + ) == ) printf("%d\n", (part(s2) - part(s1) + mod) % mod);
    else printf("%d\n", (part(s2) - part(s1) + mod + judge(s1)) % mod);
    return ;
}

P4127 [AHOI2009]同类分布

一开始想的时候当前的数肯定是不能记到答案里的

当然如果知道模数，一直取模就可以限制范围，就很好了

但问题是我们并不知道模数，这就比较尴尬了

就一直卡在这

然而正解非常暴力，但却是对的。

既然不知道模数，那就枚举模数

最后判断一下数字和是不是当前模数且能否整除就好了。

我为什么没想到呢？

注意数位dp要开long long

#include<bits/stdc++.h>
#define REP(i, a, b) for(register int i = (a); i < (b); i++)
#define _for(i, a, b) for(register int i = (a); i <= (b); i++)
using namespace std;

typedef long long ll;
const int MAXN = ;
ll dp[MAXN][MAXN*][MAXN*];
int a[MAXN], len, mod;

ll dfs(int pos, int num, int state, int lead, int limit)
{
    if(pos > len) return num == mod && state == ;
    if(dp[pos][num][state] != - && (!lead && !limit)) return dp[pos][num][state];
    int l = limit ? a[len-pos+] : ; ll res = ;
    _for(i, , l)
    {
        if(!i && lead) res += dfs(pos + , num, state, lead, limit && (i == l));
        else if(i && lead) res += dfs(pos + , i, i % mod, , limit && (i == l));
        else res += dfs(pos + , num + i, (state *  + i) % mod, , limit && (i == l));
    }
    return (!lead && !limit) ? dp[pos][num][state] = res : res;
}

ll part(ll x)
{
    len = ;
    for(; x; x /= ) a[++len] = x % ;
    ll res = ;
    for(mod = ; mod <= len * ; mod++)
    {
        memset(dp, -, sizeof(dp));
        res += dfs(, , , , );
    }
    return res;
}

int main()
{
    ll a, b;
    scanf("%lld%lld", &a, &b);
    printf("%lld\n", !a ? part(b) - part(a) : part(b) - part(a - ));
    return ;
}

P4317 花神的数论题

用二进制统计就好了

不过很奇怪的是一开始我数组开的大小是50

因为用程序输出1e15最多的位数是47

但是交上去会WA一个点

改成51就过了

以后只要空间剩余多，就多开一些吧，程序中有些神奇的地方可能会比理论上最大值超出一些

#include<bits/stdc++.h>
#define mul(a, b) a = (a * b) % mod
#define REP(i, a, b) for(register int i = (a); i < (b); i++)
#define _for(i, a, b) for(register int i = (a); i <= (b); i++)
using namespace std;

typedef long long ll;
const int MAXN = ;
const int mod = ;
ll dp[MAXN][MAXN];
int a[MAXN], len;

ll dfs(int pos, int ans, int lead, int limit)
{
    if(pos > len) return max(, ans);
    if(dp[pos][ans] != - && (!limit && !lead)) return dp[pos][ans];
    int l = limit ? a[len-pos+] : ; ll res = ;
    _for(i, , l)
    {
        if(!i && lead) mul(res, dfs(pos + , ans, lead, limit && (i == l)));
        else mul(res, dfs(pos + , ans + i, , limit && (i == l)));
    }
    return (!limit && !lead) ? dp[pos][ans] = res : res;
}

ll part(ll x)
{
    len = ;
    for(; x; x >>= ) a[++len] = x & ;
    memset(dp, -, sizeof(dp));
    return dfs(, , , );
}

int main()
{
    ll a;
    scanf("%lld", &a);
    printf("%lld\n", part(a));
    return ;
}

总结

感觉都是套路，掌握套路就好了

相信自己已经掌握了数位dp