1086 恨7不成妻（数位dp）

最新推荐文章于 2022-05-07 19:25:14 发布

yuzhang_zy

最新推荐文章于 2022-05-07 19:25:14 发布

阅读量419

点赞数

分类专栏： acwing-提高文章标签：算法

本文链接：https://blog.csdn.net/qq_39445165/article/details/120605206

版权

acwing-提高专栏收录该内容

456 篇文章 15 订阅

订阅专栏

1. 问题描述：

单身！
依然单身！
吉哥依然单身！
DS 级码农吉哥依然单身！
所以，他平生最恨情人节，不管是 214 还是 77，他都讨厌！吉哥观察了 214 和 77 这两个数，发现：
2+1+4=7
7+7=7×2
77=7×11
最终，他发现原来这一切归根到底都是因为和 7 有关！所以，他现在甚至讨厌一切和 7 有关的数！什么样的数和 7 有关呢？如果一个整数符合下面三个条件之一，那么我们就说这个整数和 7 有关：
整数中某一位是 7；
整数的每一位加起来的和是 7 的整数倍；
这个整数是 7 的整数倍。
现在问题来了：吉哥想知道在一定区间内和 7 无关的整数的平方和。

输入格式

第一行包含整数 T，表示共有 T 组测试数据。每组数据占一行，包含两个整数 L 和 R。

输出格式

对于每组数据，请计算 [L,R] 中和 7 无关的数字的平方和，并将结果对 109+7 取模后输出。

数据范围

1 ≤ T ≤ 50，
1 ≤ L ≤ R ≤ 10 ^ 18

输入样例：

3
1 9
10 11
17 17

输出样例：

236
221
0
来源：https://www.acwing.com/problem/content/1088/

2. 思路分析：

分析题目可以知道这道题目与之前的题目是不一样的，我们求解的不是一个区间中的满足某种性质的方案数目，而是求解一个区间中满足某种性质的数字的平方和，这就很棘手了，如果我们像之前的分析方式数组中只记录一个平方和是无法通过上一次数字的平方和求解出当前的平方和，通过下图可以发现我们需要同时记录上一次满足要求的数字的个数t，满足要求的数字之和，满足要求的数字的平方和，这样才可以根据上一次的信息推导出当前满足要求数字的平方和和其余的信息，如果使用迭代式的数位dp写法可以发现需要记录的信息比较多而且写起来很麻烦，所以下面使用dfs来解决。

首先需要考虑dfs方法需要传递哪些参数（参考Windy数的记忆化写法），我们可以根据题目中需要满足的性质传递以下几个动态变化的参数：当前还剩下k位数字可以填，nums的第一位到第i位的各位数字之和对7取余的结果s，第一位到第i位的数值对7取余的结果num，上一位填的是否是对应位的最大数字x = nums[k - 1]的标记lim（这个标记可以用来判断下一位可以填哪些数字），因为使用是记忆化搜索所以还需要传递一个记忆化数组f，因为达到上限lim的情况是比较少的，所以可以声明四维数组f来记录已经求解过的结果即可，一般来说有多少个动态变化的参数声明对应维度的数组记录即可，其中f[i][j][k][]表示还剩下i位数字可以填，第一位到第i位的各位数字之和对7取余的结果为j，第一位到第i位对应的数值对7取余的结果为k，因为在dfs的时候我们需要根据递归返回的结果来得到当前这一位的平方和信息，由上图可以发现需要记录满足要求的数的个数，满足要求数字的总和，满足要求数字的平方和，记录这些信息之后那么就可以通过递归返回的信息得到当前这一位的信息，在递归的时候根据上图的计算公式即可得到当前这一位的所有信息（对应代码中的res[0]，res[1]，res[2]）。这道题目使用编写的一个好处是python其实完全不用担心溢出的问题，python这个优点在对于数字很大的情况下是很赞的。

3. 代码如下：

dfs写法：

from typing import List


class Solution:
    # P为题目中规定的取余数
    P = 10 ** 9 + 7
    # 记录10的n次幂
    power = None

    def dp(self, n: int, f: List[List[List[list]]]):
        nums = list()
        while n > 0:
            nums.append(n % 10)
            n //= 10
        # 因为dfs方法返回的是一个列表而第三个元素就是平方和对P取余的结果, 所以返回递归方法的第三个元素即可
        return self.dfs(len(nums), 0, 0, nums, f, True)[2]

    # 因为这题的数位dp比较复杂所以使用记忆化搜索来写, 记忆化搜索的难度比较小一点
    def process(self):
        T = int(input())
        # f是一个特殊的数据结构, 最后一维是一个包含三个元素的列表
        f = [[[[-1, -1, -1]] * 7 for i in range(7)] for j in range(21)]
        self.power = [1]
        for i in range(1, 22):
            self.power.append(self.power[-1] * 10)
        for i in range(T):
            l, r = map(int, input().split())
            print((self.dp(r, f) - self.dp(l - 1, f) + self.P) % self.P)

    # dfs方法返回一个列表即可相当于c++中的结构体, s为第k位到最后一位的数字之和对7取余的结果
    # num为第k位到到最后一位对应的数值, lim表示上一位填的是否是最大的数字
    def dfs(self, k: int, s: int, num: int, nums: List[int], f: List[List[List[list]]], lim: bool):
        # 递归出口, 第一个元素表示满足要求数字的个数, 当各位数字的和不是7的倍数并且整个数字不是7的倍数说明合法方案加1
        if k == 0: return [1 if s and num else 0, 0, 0]
        # 因为到达上限lim的情况是很少的所以这里只记录没有达到上限lim的情况也可以
        if lim == 0 and f[k][s][num][0] >= 0: return f[k][s][num]
        up = nums[k - 1] if lim else 9
        res = [0, 0, 0]
        for i in range(up + 1):
            # 当前这一位是7直接跳过不满足要求
            if i == 7: continue
            # 递归的结果表示当前第i - 1位到最后一位数字的结果, t为一个列表包含三个信息: t[0]为满足要求的数的个数, t[1]表示满足要求的数字之和, t[2]表示满足要求的平方和
            t = self.dfs(k - 1, (s + i) % 7, (num * 10 + i) % 7, nums, f, lim and i == up)
            # res[0]累加i - 1位满足要求的个数
            res[0] = (res[0] + t[0]) % self.P
            B = i * self.power[k - 1]
            res[1] = (res[1] + (B * t[0] + t[1])) % self.P
            res[2] = (res[2] + (t[0] * B) % self.P * B % self.P + t[2] + (2 * t[1] * B) % self.P) % self.P
        if not lim: f[k][s][num] = res
        return res


if __name__ == "__main__":
    Solution().process()

迭代写法：

#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;
typedef long long LL;
const int N = 20, P = 1e9 + 7;

struct F
{
    int s0, s1, s2;
}f[N][10][7][7];

int power7[N], power9[N];

int mod(LL x, int y)
{
    return (x % y + y) % y;
}

void init()
{
    for (int i = 0; i <= 9; i ++ )
    {
        if (i == 7) continue;
        auto& v = f[1][i][i % 7][i % 7];
        v.s0 ++, v.s1 += i, v.s2 += i * i;
    }

    LL power = 10;
    for (int i = 2; i < N; i ++, power *= 10)
        for (int j = 0; j <= 9; j ++ )
        {
            if (j == 7) continue;
            for (int a = 0; a < 7; a ++ )
                for (int b = 0; b < 7; b ++ )
                    for (int k = 0; k <= 9; k ++ )
                    {
                        if (k == 7) continue;
                        auto &v1 = f[i][j][a][b], &v2 = f[i - 1][k][mod(a - j * power, 7)][mod(b - j, 7)];
                        v1.s0 = mod(v1.s0 + v2.s0, P);
                        v1.s1 = mod(v1.s1 + v2.s1 + j * (power % P) % P * v2.s0, P);
                        v1.s2 = mod(v1.s2 + j * j * (power % P) % P * (power % P) % P * v2.s0 + v2.s2 + 2 * j * power % P * v2.s1, P);
                    }
        }

    power7[0] = 1;
    for (int i = 1; i < N; i ++ ) power7[i] = power7[i - 1] * 10 % 7;

    power9[0] = 1;
    for (int i = 1; i < N; i ++ ) power9[i] = power9[i - 1] * 10ll % P;
}

F get(int i, int j, int a, int b)
{
    int s0 = 0, s1 = 0, s2 = 0;
    for (int x = 0; x < 7; x ++ )
        for (int y = 0; y < 7; y ++ )
            if (x != a && y != b)
            {
                auto v = f[i][j][x][y];
                s0 = (s0 + v.s0) % P;
                s1 = (s1 + v.s1) % P;
                s2 = (s2 + v.s2) % P;
            }
    return {s0, s1, s2};
}

int dp(LL n)
{
    if (!n) return 0;

    LL backup_n = n % P;
    vector<int> nums;
    while (n) nums.push_back(n % 10), n /= 10;

    int res = 0;
    LL last_a = 0, last_b = 0;
    for (int i = nums.size() - 1; i >= 0; i -- )
    {
        int x = nums[i];
        for (int j = 0; j < x; j ++ )
        {
            if (j == 7) continue;
            int a = mod(-last_a * power7[i + 1], 7);
            int b = mod(-last_b, 7);
            auto v = get(i + 1, j, a, b);
            res = mod(
                res + 
                (last_a % P) * (last_a % P) % P * power9[i + 1] % P * power9[i + 1] % P * v.s0 % P + 
                v.s2 + 
                2 * last_a % P * power9[i + 1] % P * v.s1,
            P);
        }

        if (x == 7) break;
        last_a = last_a * 10 + x;
        last_b += x;
        if (!i && last_a % 7 && last_b % 7) res = (res + backup_n * backup_n) % P;
    }

    return res;
}

int main()
{
    int T;
    cin >> T;

    init();

    while (T -- )
    {
        LL l, r;
        cin >> l >> r;
        cout << mod(dp(r) - dp(l - 1), P) << endl;
    }

    return 0;
}