刷题周记（十四）——#数位DP：windy数、数字计数

——2021年01月24日（周日）——————————————————

——2021年01月25日（周一）——————————————————

——2021年01月26日（周二）——————————————————

——2021年01月27日（周三）——————————————————

——2021年01月28日（周四）——————————————————

至今为止啥也没干……快期末考试了复习文化课……今天刚考完试。还有七天集训QAQ……

——2020年01月29日（周五）——————————————————

数位DP

一、windy数

#include
using namespace std;
const int N = 11;
int f[N][10];
//初始化
void init()
{
    //每个个位上取任意一个数的个数都是1
    for(int i = 0; i <= 9; i ++) f[1][i] = 1;
    //第2到第10位
    for(int i = 2; i < N; i ++)
        // j是这一位的数
        for(int j = 0; j <= 9; j ++)
            //k是上一位的数
            for(int k = 0; k <= 9; k ++)
                //相差大于等于2就可以进行转移
                if(abs(j - k) >= 2)
                    f[i][j] += f[i - 1][k];
}
//核心思路是：分两类，一类是当前位上的数没有到达极限x，那么1~x - 1这几种情况就直接用我们初始化的数相加。
//另一类就是：当前位上的数已经是极限x了，那么我们先判断能不能用，能用的话就到下一位进行一样的操作。
//因为这个位上的数取到极限的时候，那它的下一位就会被限制。
//比如n=223的时候，如果第一位取1，那下面两位随便取；如果第一位取了2，那么下面最多取到2；
int dp(int n)
{
    if(!n) return 0;
    
    vector<int> nums;
    while(n) nums.push_back(n % 10), n /= 10;
    
    int res = 0; 
    int last = -2;
    for(int i = nums.size() - 1; i >= 0; i --)
    {
        //当前位数的数
        int x = nums[i];
        //枚举的是下一位数
        //如果i等于最高位j是1，不然就是0；== 会返回0或者1；
        for(int j = i == nums.size() - 1; j < x; j ++)
            if(abs(j - last) >= 2)
                res += f[i + 1][j];
        //这是最后一个数的处理
        if(abs(x - last) >= 2) last = x;
        //注意，这里要是有一次不满足就会直接断掉。
        else break;
        //这是个位到达了最大值也就是当前数已经是n的时候，将n加上，res++；
        if(!i) res ++;
    }
    //这里是将那些前导有0的情况都补上。
    for(int i = 1; i < nums.size(); i ++)
        for(int j = 1; j <= 9; j ++)
            res += f[i][j];
            
    return res;
}

int main()
{
    init();
    int l , r;
    cin >> l >> r;
    //用右边界的数减去左边界的数
    cout << dp(r) - dp(l - 1) << endl;
    return 0;
}

——2021年01月30日（周六）——————————————————

二、数字计数

洛谷上的题目
Acwing上的题目
没什么特别的，就是数字的范围大了点。
可以参考 计数问题的题解

#include 
#include 
#include 
using namespace std;
typedef long long ll;
const int N = 10;
//get前面前缀部分的数值，即前面前缀总方案数
ll get(vector<int> num, int l, int r)
{
    ll res = 0;
    for (int i = l; i >= r; i -- ) res = res * 10 + num[i];
    return res;
}

//后缀有几位就是十的几次方
ll power10(int x)
{
    ll res = 1;
    while (x -- ) res *= 10;
    return res;
}

//这是1到n中i出现的次数
ll count(ll n, int x){
	//0的话就不要讨论了
    if (!n) return 0;
	//将n的每一位都拆下来
    vector<int> num;
    while (n){
        num.push_back(n % 10);
        n /= 10;
    }
    n = num.size();
	//接下来是统计在当前位置上取某个数会有多少种方案
    ll res = 0;
    for (int i = n - 1 - !x; i >= 0; i -- ){
    	//如果i所在的不是最高位,那么就会有前缀，那么我们就来先处理前缀小于abc的情况
        if (i < n - 1){
        //res += 前缀的值 * 10的后缀的次方
        //这里前缀的情况应该是0~前缀（abc）-1，一共abc种情况，并没有把abc这种情况也算进去
            res += get(num, n - 1, i + 1) * power10(i);
            //如果x是0的话，前缀里面会少一种情况（就是这个情况：0...0，因为想要这一位取0，那么前缀不可能全是0）；
            //比如三位数里想要第二位取0，那么就可以有102,103,106……但是绝对不会有002,003,006……等情况存在，不是吗？
            if (!x) res -= power10(i);
        }
        //然后我们来处理前缀就是abc的情况，当然啦，这里就不管有没有前缀了，都一样的~
		//当前要取的数x 与 目标最大值的这一位数相等的时候 ，就是后面构成的数再加1（0这种情况）
        if (num[i] == x) res += get(num, i - 1, 0) + 1;
        //当前要取的数x 小于 目标最大值的这一位数 的时候，只要加上十的后面的数的位数的次方
        else if (num[i] > x) res += power10(i);
    }

    return res;
}

int main()
{
    ll a, b;
    cin >> a >> b;
   	 	//保证a小于b
        if (a > b) swap(a, b);
		//分位置来讨论 每一位上 取 某一个数 会有多少种情况
        for (int i = 0; i <= 9; i ++ )
            cout << count(b, i) - count(a - 1, i) << ' ';
        cout << endl;
    

    return 0;
}

三、计数问题

这个做法似乎比较通用，特地来学一下。
但是好难理解……劝退
思想：DFS
从最高位开始往个位枚举，假设当前位置是目标数x；
下一位数可以是不超过上限的所有数
加入下一位枚举到了目标数，且前导木有0，那么sum++

#include
using namespace std;
const int N = 2010;
typedef long long ll;
ll f[10][N], num[10];
int a, b;
//有无前导0.当前位置的数字是否到了上限， 当前位置， 要找的x，x的总出现次数
ll dfs(bool lead, bool lim, int pos, int x, int sum)
{
    //找到了最后一位的后一位，返回数量
    if(!pos) return sum;
    //前导不是0，限制是0，这个位置上目标数字出现次数为sum的数字的个数不是-1
    if(lead && !lim && (~f[pos][sum])) return f[pos][sum];
    //如果没有到限制，那么up可以到9，如果到了限制那么就只能到限制；
    int res = 0, up = lim ? num[pos] : 9;
    //枚举下一位的数（不超过限制就好）
    for(int i = 0; i <= up; i ++)
    {
        //前导不是0，有没有到上限，位置
        res += dfs(lead | i, lim && i == up, pos - 1, x, sum + ((lead | i) && i == x));
    }
    //没前导0且没有到达极限
    //这里是第一次找到当前状态（在前n位里面随机分配sum个x）的值，记录下来下一次找到相同情况可以直接调用。
    if(lead && !lim) f[pos][sum] = res;
    return res;
}

//最大上限，目标数字
int dp(int n, int x)
{
    //最大长度
    int cnt = 0;
    while(n)
    {
        num[++ cnt] = n % 10;
        n /= 10;
    }
    return dfs(0, 1, cnt, x, 0);
}

int main()
{
    while(cin >> a >> b, a || b)
    {
        if(a > b) swap(a, b);
        for(int i = 0; i <= 9; i ++)
        {
            memset(f, -1, sizeof f);
            cout << dp(b, i) - dp(a - 1, i) << " ";
        }
        cout << endl;
    }
    return 0;
}

——（完）——————————————————

To be continue……

f[a][k代表从a开始算起，长度为2^k的区间的最大（最小）值是多少
由于长度被划分为二进制的样子，所以每次计算从a开始的长度为2^k+1的区间中最大（最小）值的时候，只需要将f[a][ 2^k+1 ] 以及f[a + 2^k+1][2^k+1]进行比较就好了。