数位DP

数位DP

嗯，作为一类比较自成一派的DP还是要学一下。

其实不是很难，主要通过记忆化搜索实现。

用例题来讲解吧。

---

第一道数位DP/洛谷三萌成就达成！

洛谷P3413 萌数

大意:求[l, r]中存在长度至少为2的回文子串的数的个数，对1e9+7取模。

r <= 10^1000

首先可以发现，回文串长度为2或3即可。

然后我们就设计状态：f[k][last][ll][0/1][0/1]表示后k位中，第k + 1位是last，第k + 2位是ll，k位之前是否已出现回文串，k位之前是否出现过非0数(不是全是前导0)，满足条件的数的个数。

枚举k位放什么即可。顺便更新一波状态。

注意有limit的时候记忆化无用，要往后算。

#include <cstdio>
#include <algorithm>
#include <cstring>

const int N = 1010, MO = 1000000007;

int f[N][11][11][2][3], num[N];

int DFS(int k, int last, int ll, int sta, int first, bool limit) {
    if(k == 0) {
        return sta;
    }
    if(!limit && f[k][last][ll][sta][first] != -1) {
        return f[k][last][ll][sta][first];
    }
    int ans = 0;
    int large = limit ? num[k] : 9;
    for(int i = 0; i <= large; i++) {
        if(sta) {
            ans += DFS(k - 1, i, last, sta, first, limit && (i == num[k]));
            ans %= MO;
        }
        else {
            int temp = 0;
            if(first == 1) {
                temp = (i == last);
            }
            else if(first == 2) {
                temp = (i == last) || (i == ll);
            }
            int second = first;
            if(i || first) {
                second = std::min(2, second + 1);
            }
            ans += DFS(k - 1, i, last, temp, second, limit && (i == num[k]));
            ans %= MO;
        }
    }
    if(!limit) {
        f[k][last][ll][sta][first] = ans;
    }
    //printf("%d %d %d %d %d %d = %d 
", k, last, ll, sta, first, limit, ans);
    return ans;
}

char str[N];

int main() {
    memset(f, -1, sizeof(f));

    scanf("%s", str);
    int n = strlen(str);
    for(int i = n - 1; i >= 0; i--) {
        num[n - i] = str[i] - '0';
    }
    int temp = 0;
    if(n > 1 || num[1]) {
        num[1]--;
        int t = 1;
        while(num[t] < 0) {
            num[t] += 10;
            num[t + 1]--;
            t++;
        }
        if(!num[n]) {
            n--;
        }
        temp = DFS(n, 10, 10, 0, 0, 1);
    }

    scanf("%s", str);
    n = strlen(str);
    for(int i = n - 1; i >= 0; i--) {
        num[n - i] = str[i] - '0';
    }
   
    int ans = DFS(n, 10, 10, 0, 0, 1) - temp;
    ans = (ans % MO + MO) % MO;
    printf("%d", ans);
    return 0;
}

---

洛谷P2657 windy数

大意：求[l, r]之中每两个相邻数码之差大于1的数的个数。

这还比前一道题水一点......

f[k][last][0/1]表示后k位，第k + 1位是last，k位之前是否全是0的满足条件的数的个数。

然后就过了。

#include <cstdio>
#include <algorithm>
#include <cstring>

const int N = 20;

int f[N][10][2], num[N];

int DFS(int k, int last, int sta, bool limit) {
    if(k == 0) {
        return 1;
    }
    if(!limit && f[k][last][sta]) {
        return f[k][last][sta];
    }

    int ans = 0;
    int large = limit ? num[k] : 9;
    for(int i = 0; i <= large; i++) {
        if(sta) {
            if(i <= last + 1 && i >= last - 1) {
                continue;
            }
            ans += DFS(k - 1, i, sta, limit && (i == num[k]));
        }
        else {
            ans += DFS(k - 1, i, i > 0, limit && (i == num[k]));
        }
    }

    if(!limit) {
        f[k][last][sta] = ans;
    }
    //printf("%d %d %d %d %d 
", k, last, sta, limit, ans);
    return ans;
}

inline int solve(int x) {
    if(!x) {
        return 1;
    }
    int n = 0;
    while(x) {
        num[++n] = x % 10;
        x /= 10;
    }
    return DFS(n, 0, 0, 1);
}

int main() {

    int a, b;
    scanf("%d%d", &a, &b);
    printf("%d", solve(b) - solve(a - 1));

    return 0;
}

注意有一个细节：这两题(大部分)中，sta状态(就是之前是否全是0)其实可以只在DFS函数中传，而不在f数组中多开一维。

原理我还没想清楚呢......闲的没事还是加上好了，避免出锅。

---

洛谷P2518 计数

比较特立独行的一道题.....

大意：给你若干个数码，总和<=50，让你求比给定的某一个全排列字典序小的全排列数。

保证答案在long long内。

就相当于给定每个数个数的数位DP。

先开个桶。可以发现，按照上面的套路的话，!limit的时候可以直接用公式。

然后就直接过了......我的map其实没啥用，就比暴力快了0.1ms........

至于统计过程中爆long long...大家各显神通吧。我是分解质因数。也可以拆成若干个组合数相乘，避免除法。

#include <cstdio>
#include <map>
#include <cstring>

typedef long long LL;
const int N = 60;

struct STA {
    int a[11];
    inline bool operator <(const STA &w) const {
        for(int i = 0; i <= 10; i++) {
            if(a[i] != w.a[i]) {
                return a[i] < w.a[i];
            }
        }
        return 0;
    }
    inline bool operator ==(const STA &w) const {
        for(int i = 0; i <= 10; i++) {
            if(a[i] != w.a[i]) {
                return 0;
            }
        }
        return 1;
    }
}bin;

std::map<STA, LL> mp;
int p[N], cnt[N], top, num[N];
char str[N];
bool vis[N];
std::map<STA, LL>::iterator it;

inline LL qpow(LL a, LL b) {
    LL ans = 1;
    while(b) {
        if(b & 1) {
            ans *= a;
        }
        a *= a;
        b = b >> 1;
    }
    return ans;
}

inline void getp(int b) {
    for(int i = 2; i <= b; i++) {
        if(!vis[i]) {
            p[++top] = i;
        }
        for(int j = 1; j <= top && i * p[j] <= b; j++) {
            vis[i * p[j]] = 1;
            if(i % p[j] == 0) {
                break;
            }
        }
    }
    return;
}

inline void add(int x, int v) {
    //printf("add : %d %d 
", x, v);
    for(int i = 1; i <= top && x > 1; i++) {
        while(x % p[i] == 0) {
            cnt[i] += v;
            x /= p[i];
        }
    }
    return;
}

inline LL cal(int k) {
    memset(cnt, 0, sizeof(cnt));
    for(int i = 2; i <= k; i++) {
        add(i, 1);
    }
    for(int i = 0; i <= 9; i++) {
        for(int j = 2; j <= bin.a[i]; j++) {
            add(j, -1);
        }
    }
    LL ans = 1;
    for(int i = 1; i <= top; i++) {
        if(cnt[i]) {
            ans *= qpow(p[i], cnt[i]);
        }
    }
    return ans;
}

LL DFS(int k, bool limit) {
    if(k == 0) {
        return 1;
    }
    it = mp.find(bin);
    if(!limit && it != mp.end()) {
        return it->second;
    }
    if(!limit) {
        LL ans = cal(k);
        mp[bin] = ans;
        return ans;
    }
    int large = limit ? num[k] : 9;
    LL ans = 0;
    for(int i = 0; i <= large; i++) {
        if(!bin.a[i]) {
            continue;
        }
        bin.a[i]--;
        ans += DFS(k - 1, limit && (i == num[k]));
        bin.a[i]++;
    }
    /*printf("%d %d %lld 
", k, limit, ans);
    for(int i = 0; i <= 9; i++) {
        printf("%d ", bin.a[i]);
    }
    puts("");*/
    return ans;
}

int main() {
    getp(50);
    scanf("%s", str);
    int n = strlen(str);
    for(int i = n - 1; i >= 0; i--) {
        num[n - i] = str[i] - '0';
        bin.a[num[n - i]]++;
    }

    printf("%lld
", DFS(n, 1) - 1);
    return 0;
}

---

洛谷P2602 数字计数

大意：求在[l, r]之中每个数码出现了几次。

首先简化它，对每个数码分别做。

这里的状态是f[k][0/1]表示在后k位是否中含有数码aim的个数。aim是枚举的。

然后我们发现，如果我们当前选的数码恰好是aim，那么额外加上后面的总个数就行了。

#include <cstdio>
#include <cstring>

typedef long long LL;
const int N = 20;

LL f[N][2], pw[N], s;
int num[N], aim;

LL DFS(int k, int sta, bool limit) {
    if(k == 0) {
        return sta == 0 && aim == 0;
    }
    if(!limit && f[k][sta] != -1) {
        return f[k][sta];
    }
    LL ans = 0;
    int large = limit ? num[k] : 9;
    for(int i = 0; i <= large; i++) {
        if(sta) {
            ans += DFS(k - 1, sta, limit && (i == num[k]));
        }
        else {
            ans += DFS(k - 1, i > 0, limit && (i == num[k]));
        }
        if(i == aim && (sta || i)) {
            if(limit && i == num[k]) {
                ans += s % pw[k - 1] + 1;
            }
            else {
                ans += pw[k - 1];
            }
        }
    }
    if(!limit) {
        f[k][sta] = ans;
    }
    return ans;
}

inline LL solve(LL x) {
    if(!x) {
        return !aim;
    }
    int n = 0;
    s = x;
    while(x) {
        num[++n] = x % 10;
        x /= 10;
    }
    return DFS(n, 0, 1);
}

int main() {
    LL a, b;
    scanf("%lld%lld", &a, &b);
    pw[0] = 1;
    for(int i = 1; i <= 15; i++) {
        pw[i] = pw[i - 1] * 10;
    }

    for(int i = 0; i <= 9; i++) {
        aim = i;
        memset(f, -1, sizeof(f));
        printf("%lld ", solve(b) - solve(a - 1));
    }
    return 0;
}

---

参考资料：红太阳的博客。

总结一下：基本都是套路......做的都是板题.......

哇！他们考的都好难啊.....要命哇...

CF747F：一个比较独特的数位DP。