hihoCoder #1770 : 单调数（数位dp）

题面

咱们定义一个数是单调数，当且仅当构成这个数每个数位都是单调不降或不增的。

例如 \(123\) 和 \(321\) 和 \(221\) 和 \(111\) 是单调的，而 \(312\) 不是单调的。

给定 \(T\) 组 \(l, r\)，每次询问 \([l, r]\) 中有几个单调的数。

\(l, r \le 10 ^ {18}, T \le 10^4\)

题解

今天 hihoCoder 居然 \(AK\) 了，真舒服（虽然题目很水，还被罚时坑惨了）qwq

显然考虑一个数位 \(dp\) ，不难发现咱们只须要记下当前在哪一位，以及最后一位是什么数字就好了。

而后对于不降和不增作个两遍就好了，但有不少细节后面细讲。

写的时候发现本身摸索了一套数位 \(dp\) 的套路？（逃

套路：

咱们经常是要求 \(\le n\) 的有多少个知足要求的数。

这个限制有些恶心，咱们须要多一位来看是否被限制。

咱们通常按位考虑，令 \(dp[i][0 / 1]\) 为到从高到低考虑到第 \(i\) 位，当前有/没被 \(n\) 限制。

咱们考虑把 \(n\) 按位拆下来，变成一个数组 lim[i] ，而后取出 \(n\) 的位数 Bit 。

每次考虑后一位放什么数字就好了。具体实现以下（用刷表法方便转移）：

dp[0][0] = 1;
for (int i = 0; i < Bit; ++ i)
    for (int now = 0; now <= 1; ++ now)
      for (int dig = 0; dig <= 9; ++ dig) if (now || (dig <= lim[i + 1]))
          dp[i + 1][now || (dig < lim[i + 1])] += dp[i][now];

而后最后的答案就是

ans = dp[Bit][0] + dp[Bit][1];

不难发现这样写，每一个位数的数都会被考虑到。由于咱们枚举的时候容许了前缀 \(0\) 的存在。

而且若是存在前缀 \(0\) 那么后面的全部数都不会存在限制了，能够随便填。

可是注意这样的话，所有为 \(0\) 的也会考虑进去，咱们日常要考虑是否 \(-1\) 就好了。

对于这道题咱们能够类比这种方法去作。

首先把答案差分表示 \(ans = ans_r - ans_{l - 1}\) 。

而后令 dp[i][j][0/1] 为到第 \(i\) 位，最后一次填 \(j\) ，有/没 被 \(n\) 限制住的状况。

直接这样写的话，递增是没有问题的，递减的时候就会存在问题了。

由于咱们把前导 \(0\) 考虑进去了，结果致使没有正确算上这部分贡献。

因此咱们还要多一维，也就是 dp[i][j][0/1][0/1] 前三个同上，最后一个意义是当前彻底不/是前缀 \(0\) 。

而后转移的时候也是枚举数字，而后按照两种状况考虑下填的这个数的限制就好了。

注意有一些数会被递增递减算两次，也就是 \(111\) ，\(3333\) ，这些彻底相同的数。能够直接暴力枚举减去就好了。

复杂度是 \(O(T * 18 * 10)\) 的。

总结

碰到数位 \(dp\) 直接上套路去讨论。

而后就须要对于具体问题具体分析了，根据题目要求设出须要的状态。

有时候能够根据须要卡卡状态数，由于一般不可能到满。

必定要写个暴力拍，这个东西其实很好调？

代码

建议看看代码，其实写的很简洁？（可读性也是很鲁棒的qwq）

#include <bits/stdc++.h>

#define For(i, l, r) for(register int i = (l), i##end = (int)(r); i <= i##end; ++i)
#define Fordown(i, r, l) for(register int i = (r), i##end = (int)(l); i >= i##end; --i)
#define Set(a, v) memset(a, v, sizeof(a))
#define Cpy(a, b) memcpy(a, b, sizeof(a))
#define debug(x) cout << #x << ": " << x << endl
#define DEBUG(...) fprintf(stderr, __VA_ARGS__)

using namespace std;

inline bool chkmin(int &a, int b) {return b < a ? a = b, 1 : 0;}
inline bool chkmax(int &a, int b) {return b > a ? a = b, 1 : 0;}

inline int read() {
    int x = 0, fh = 1; char ch = getchar();
    for (; !isdigit(ch); ch = getchar()) if (ch == '-') fh = -1;
    for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + (ch ^ 48);
    return x * fh;
}

void File() {
#ifdef zjp_shadow
    freopen ("1770.in", "r", stdin);
    freopen ("1770.out", "w", stdout);
#endif
}

typedef long long ll;
ll dp[19][10][2][2];

int lim[19];
inline int Get_Bit(ll x) {
    int tot = 0; 
    for (; x; x /= 10) lim[++ tot] = x % 10;
    reverse(lim + 1, lim + tot + 1);
    return tot;
}

inline ll Calc(ll n) {

    if (!n) return 0;

    ll ans = 0;

    For (opt, 0, 1) {
        Set(dp, 0); dp[0][0][0][1] = 1;

        int Bit = Get_Bit(n);
        For (i, 0, Bit - 1) For (j, 0, 9) For(now, 0, 1) For (fir, 0, 1) {
            For (dig, opt ? 0 : j, opt ? (fir ? 9 : j) : 9) if (now || dig <= lim[i + 1])
                dp[i + 1][dig][now || (dig < lim[i + 1])][fir && !dig] += dp[i][j][now][fir];
        }

        For (j, 0, 9) For(now, 0, 1) For (fir, 0, 1) ans += dp[Bit][j][now][fir];

        -- ans;
    }

    For (dig, 1, 9) {
        ll tmp = dig;
        while (tmp <= n) -- ans, tmp = tmp * 10 + dig;
    }

    return ans;

}

int main() {

    File();

    for (int cases = read(); cases; -- cases) {
        ll l, r; cin >> l >> r;
        printf ("%lld\n", Calc(r) - Calc(l - 1));
    }

    return 0;

}