蓝桥杯真题Day39 倒计时20天 纯练题！

[蓝桥杯 2019 省 B] 特别数的和

题目描述

小明对数位中含有 2、0、1、9 的数字很感兴趣（不包括前导 0），在 1 到 40 中这样的数括 1、2、9、10 至 32、39 和 40，共 28 个，他们的和是 574。

请问，在 1 到 n 中，所有这样的数的和是多少？

输入格式 输入一行包含一个整数 n。

输出格式 输出一行，包含一个整数，表示满足条件的数的和。

思路提示

• 可以通过循环，每次把当前数字对 10 取模，得到个位数。

• 若个位数等于 2、0、1、9 中的任意一个，那么说明这个数字满足条件，直接跳出循环即可。

• 每次循环时，将数字除以 10。

• 直到数字为 0 时循环结束。

• 若数字为 0，就代表它不满足条件。

代码表示

#include <bits/stdc++.h>
using namespace std;

int main() {
    int n, sum = 0;

    cin >> n;
    for (int i = 1; i <= n; i++) {
        int num = i;
        while (num > 0) {
            int digit = num % 10;//取当前数字的个位出来 
            if (digit == 0 || digit == 1 || digit == 2 || digit == 9) {
                sum += i;
                break;
            }
            num /= 10;//当前的个位判断过后，除十把原来十位的放在个位上来处理 
        }
    }
   cout << sum << endl;
   return 0;
}

---

蓝桥杯第十四届省赛真题-冶炼金属

题目描述

小蓝有一个神奇的炉子用于将普通金属 O 冶炼成为一种特殊金属 X。这个炉子有一个称作转换率的属性 V，V 是一个正整数，这意味着消耗 V 个普通金属 O 恰好可以冶炼出一个特殊金属 X，当普通金属 O 的数目不足 V 时，无法继续冶炼。现在给出了 N 条冶炼记录，每条记录中包含两个整数 A 和 B，这表示本次投入了 A 个普通金属 O，最终冶炼出了 B 个特殊金属 X。每条记录都是独立的，这意味着上一次没消耗完的普通金属 O 不会累加到下一次的冶炼当中。

根据这 N 条冶炼记录，请你推测出转换率 V 的最小值和最大值分别可能是多少，题目保证评测数据不存在无解的情况。

输入格式

第一行一个整数 N，表示冶炼记录的数目。

接下来输入 N 行，每行两个整数 A、B，含义如题目所述。

输出格式

输出两个整数，分别表示 V 可能的最小值和最大值，中间用空格分开。

样例输入

3

75 3

53 2

59 2

样例输出

20 25

代码表示

#include <bits/stdc++.h>
using namespace std;
int main() {
    long long n,v1,v2;
    cin >> n;

    long long arr[n],aar[n];
    for (long long i = 0; i < n; ++i) {
        long long a, b;
        	cin >> a >> b;
        	v1=a/b;
        	v2=a/(b+1);
        	arr[i]=v1;
        	aar[i]=v2;	
    }
    long long* maxVal = max_element(aar, aar + n);
    long long* minVal = min_element(arr, arr + n);

    cout << *maxVal+1 << " " << *minVal;

    return 0;
}

心得体会

那道题之后发现怎么都不行，一定要多写一些数据说不定就是加一减一的问题。

这个正向的取整肯定是行不通，所以要加一“再加一”来完成。

注意：long long* maxVal = max_element(aar, aar + n);用于数组来求最大值。

---

蓝桥杯第十四届省赛真题-飞机降落

题目描述

N 架飞机准备降落到某个只有一条跑道的机场。其中第 i 架飞机在 Ti 时刻到达机场上空，到达时它的剩余油料还可以继续盘旋 Di 个单位时间，即它最早可以于 Ti 时刻开始降落，最晚可以于 Ti + Di 时刻开始降落。降落过程需要 Li个单位时间。一架飞机降落完毕时，另一架飞机可以立即在同一时刻开始降落，但是不能在前一架飞机完成降落前开始降落。请你判断 N 架飞机是否可以全部安全降落。

输入格式

输入包含多组数据。第一行包含一个整数 T，代表测试数据的组数。

对于每组数据，第一行包含一个整数 N。

以下 N 行，每行包含三个整数：Ti，Di 和 Li。

输出格式

对于每组数据，输出 YES 或者 NO，代表是否可以全部安全降落。

样例输入

2
3
0 100 10
10 10 10
0 2 20
3
0 10 20
10 10 20
20 10 20

样例输出

YES
NO

提示

对于第一组数据，可以安排第 3 架飞机于 0 时刻开始降落，20 时刻完成降落。安排第 2 架飞机于 20 时刻开始降落，30 时刻完成降落。安排第 1 架飞机于 30 时刻开始降落，40 时刻完成降落。

对于第二组数据，无论如何安排，都会有飞机不能及时降落。

对于 30% 的数据，N ≤ 2。

对于 100% 的数据，1 ≤ T ≤ 10，1 ≤ N ≤ 10，0 ≤ Ti , Di , Li ≤ 10^5。

#include<bits/stdc++.h>
using namespace std;

class plane{
	//定义一个类并初始化这些量 
public:
    int st;//最早开始时间 
    int con;//可持续费的时间 
    int netm;//落地需要的时间  
    plane(int s,int c,int ne){
        st=s;
        con=c;
        netm=ne;
    } 
};
//递归函数 
//飞机列表 v、飞机状态列表 bl、上一架飞机的降落时间 pre 和已经安全降落的飞机数量 count
bool dfs(vector<plane> &v,vector<bool> &bl,int pre,int count)
{
    if(count==v.size()) //已全部成功降落 
	       return true;
    for(int i=0;i<v.size();i++){
        if(!bl[i]){
            bl[i]=true;
            if(pre<v[i].st)//上一架飞机的降落时间 pre 小于当前飞机的最早开始时间 v[i].st
            {
            	//递归调用 dfs 函数，将上一架飞机的降落时间更新为当前飞机的降落时间加上落地所需时间 v[i].netm，
				//并增加已安全降落的飞机数量 count+1
                if(dfs(v,bl,v[i].st+v[i].netm,count+1))
				    return true;
            }
			else if(pre<=v[i].st+v[i].con)//这个是在最早开始和最晚开始之间的一个函数 
			{
                if(dfs(v,bl,pre+v[i].netm,count+1))//和上面不同的就是更新的时间的不同 
				    return true;
            }
            bl[i]=false;//都不满足 
        }
    }
    //所有飞机都尝试过后仍无法全部安全降落，函数返回 false 
    return false;
}
int main(){
    int t;
    cin>>t;
    while(t--){
        int n;
        cin>>n;
        vector<plane> v;//存储飞机对象
//声明一个名为bl的布尔型向量（vector），其长度为n，并将所有元素初始化为false，
		//用于记录每个飞机的状态（是否已经安全降落）
        vector<bool> bl(n,false);
        
        while(n--){
//当前飞机的最早开始时间、可持续盘旋时间和落地所需时间
            int t,d,l;
            cin>>t>>d>>l;
            v.push_back(plane(t,d,l));
        }
//调用dfs函数，将飞机向量v、状态向量bl、
//上一架飞机的降落时间初始值0和已经安全降落的飞机数量初始值0作为参数
        if(dfs(v,bl,0,0)) cout<<"YES"<<endl;
        else cout<<"NO"<<endl;
    }
    return 0;
}

心得体会 

递归调用DFS（深度优先搜索）是指在DFS算法中，函数自身在某个步骤中调用自身来实现进一步的搜索。在这段代码中，递归调用DFS用于在每个步骤中继续搜索下一个飞机的降落顺序。

1. 首先，在dfs函数中，检查是否已经找到了一种安全降落顺序。如果已经找到，则返回`true`表示成功找到一种安全降落顺序。
2. 如果未找到安全降落顺序，则进行以下步骤：
   - 对于当前飞机的遍历，依次考虑每个飞机。
   - 对于每个飞机，检查它是否已经安全降落。如果已经安全降落，则跳过该飞机，处理下一个飞机。
   - 如果当前飞机未安全降落，则计算当前飞机的降落时间，并更新当前时间`curTime`为计算得到的降落时间。
   - 将当前飞机标记为已经安全降落，即将状态向量`bl`中对应位置的值设为`true`。
   - 递归调用`dfs`函数，传递更新后的参数，即继续搜索下一个飞机的降落顺序。
   - 将递归调用的返回值存储在临时变量`result`中。
   - 如果`result`为`true`，则表示在下一层的递归调用中找到了一种安全降落顺序。此时，将`true`作为最终的返回值，表示成功找到一种安全降落顺序。
   - 如果`result`为`false`，则回溯到上一步，将当前飞机标记为未安全降落，即将状态向量`bl`中对应位置的值设为`false`。
3. 如果所有飞机都被遍历完毕，仍未找到安全降落顺序，则返回`false`表示无法找到安全降落顺序。

这样，通过递归调用DFS函数，不断在每个步骤中调用自身来进一步搜索下一个飞机的降落顺序，直到找到一种安全降落顺序或遍历完所有情况为止。递归调用DFS的过程可以看作是一种深度优先的搜索策略，通过不断向下深入搜索，直到达到终止条件或无法继续搜索为止。

---

蓝桥杯第十四届省赛真题-接龙数列

题目描述

对于一个长度为 K 的整数数列：A1, A2, . . . , AK，我们称之为接龙数列当且仅当 Ai 的首位数字恰好等于 Ai−1 的末位数字 (2 ≤ i ≤ K)。

例如 12, 23, 35, 56, 61, 11 是接龙数列；12, 23, 34, 56 不是接龙数列，因为 56的首位数字不等于 34 的末位数字。所有长度为 1 的整数数列都是接龙数列。

现在给定一个长度为 N 的数列 A1, A2, . . . , AN，请你计算最少从中删除多少个数，可以使剩下的序列是接龙序列？

输入格式

第一行包含一个整数 N。

第二行包含 N 个整数 A1, A2, . . . , AN。

输出格式

一个整数代表答案。

样例输入

5
11 121 22 12 2023

样例输出

1

提示

删除 22，剩余 11, 121, 12, 2023 是接龙数列。

对于 20% 的数据，1 ≤ N ≤ 20。

对于 50% 的数据，1 ≤ N ≤ 10000。

对于 100% 的数据，1 ≤ N ≤ 10^5，1 ≤ Ai ≤ 10^9。所有 Ai 保证不包含前导 0。

代码表示

#include <bits/stdc++.h>
using namespace std;
int dp[10];
int main () {
    int n, mx = 0; cin >> n;
    for (int i = 0; i < n; i ++) {
        string s; cin >> s;
        int a = s[0] - '0', b = s.back() - '0';
        dp[b] = max(dp[b], dp[a] + 1), mx = max(mx, dp[b]);
    }
    cout << n - mx << endl;
    return 0;
}

思路提示：

总数目 N 减去最长的接龙序列长度，得到的结果就是我们需要删除的最少数目，才能使剩下的序列成为接龙序列

s.back() 是一个 C++ 中的字符串操作，它用于获取字符串 s 的最后一个字符。

这个题简直是脑力王者的盛宴，核心是: dp[b] = max(dp[b], dp[a] + 1)

动态规划状态转移方程: dp[i][b] = max(dp[i - 1][b], dp[i - 1][a] + 1)其中 dp[i][j] 表示前 i 个数中，以数字 j 结尾的最长接龙数列的长度

• dp[i][b] 表示在前 i 个数中，以数字 b 结尾的最长接龙数列的长度。
• dp[i - 1][b] 表示不将当前数字 b 加入接龙数列的情况下，以数字 b 结尾的最长接龙数列的长度。
• dp[i - 1][a] + 1 表示将当前数字 b 加入以数字 a 结尾的接龙数列中，形成一个更长的接龙序列的长度。

5

11 121 22 12 2023

输出是：1   对于上面的那个式子，用到22 12 2023这里的时候，对于i-1若以1结尾说明i-1的尾元素是i的首元素a所以加1。若i-1的尾元素是以b开头的就相当于这里的22以2结尾且这个2是12的尾元素2（即为下一个2023的首元素）即不进行加1，也就是这个数他不是接龙数列。

想了快2天可算是像通人家大神的代码了。

---

蓝桥杯第十四届省赛真题-岛屿个数

题目描述

小蓝得到了一副大小为 M × N 的格子地图，可以将其视作一个只包含字符‘0’（代表海水）和 ‘1’ （代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的 ‘1’ 相连接而形成。

在岛屿 A 所占据的格子中，如果可以从中选出 k 个不同的格子，使得他们的坐标能够组成一个这样的排列：(x0, y0),(x1, y1), . . . ,(xk−1, yk−1)，其中(x(i+1)%k , y(i+1)%k) 是由 (xi , yi) 通过上/下/左/右移动一次得来的 (0 ≤ i ≤ k − 1)，

此时这 k 个格子就构成了一个 “环”。如果另一个岛屿 B 所占据的格子全部位于这个 “环” 内部，此时我们将岛屿 B 视作是岛屿 A 的子岛屿。若 B 是 A 的子岛屿，C 又是 B 的子岛屿，那 C 也是 A 的子岛屿。

请问这个地图上共有多少个岛屿？在进行统计时不需要统计子岛屿的数目。

输入格式

第一行一个整数 T，表示有 T 组测试数据。

接下来输入 T 组数据。对于每组数据，第一行包含两个用空格分隔的整数M、N 表示地图大小；接下来输入 M 行，每行包含 N 个字符，字符只可能是‘0’ 或 ‘1’。

输出格式

对于每组数据，输出一行，包含一个整数表示答案。

样例输入

2
5 5
01111
11001
10101
10001
11111
5 6
111111
100001
010101
100001
111111

样例输出

1
3

提示

对于第一组数据，包含两个岛屿，下面用不同的数字进行了区分：

01111

11001

10201

10001

11111

岛屿 2 在岛屿 1 的 “环” 内部，所以岛屿 2 是岛屿 1 的子岛屿，答案为 1。

对于第二组数据，包含三个岛屿，下面用不同的数字进行了区分：

111111

100001

020301

100001

111111

注意岛屿 3 并不是岛屿 1 或者岛屿 2 的子岛屿，因为岛屿 1 和岛屿 2 中均没有“环”。

对于 30% 的评测用例，1 ≤ M, N ≤ 10。

对于 100% 的评测用例，1 ≤ T ≤ 10，1 ≤ M, N ≤ 50。

代码表示

#include <bits/stdc++.h>
using namespace std;
//简化循环语句的编写For(i, x)展开后的代码相当于for (int i = 0; i < x; i++)
#define For(i, x) for (int i = 0; i < x; i++)
#define For1(i, x) for (int i = 1; i <= x; i++)
int t, m, n;
//四连通和八连通的方向
int next4[4][2] = { { -1, 0 }, { 0, 1 }, { 1, 0 }, { 0, -1 } }, // 四连通一个包含4个元素的二维数组
    next8[8][2] = { { -1, 0 }, { -1, 1 }, { 0, 1 }, { 1, 1 }, { 1, 0 }, { 1, -1 }, { 0, -1 }, { -1, -1 } }; // 八连通
char sea[52][52]; // 至少52x52存储地图的信息。
void dfs(int x, int y) { // 第一次搜索
    sea[x][y] = '2';//标记为2表示已经访问过 
    int newx, newy;//存储新的位置 
    For(i, 8) //宏定义展开循环 
	{
	//根据当前位置和方向的偏移量计算新的位置。 
        newx = x + next8[i][0], newy = y + next8[i][1];
    //判断新的位置是否在地图范围内，并且是未被访问过的陆地。
        if (0 <= newx && newx <= m + 1 && 0 <= newy && newy <= n + 1 && sea[newx][newy] == '0')
            dfs(newx, newy);
    }
}
void dfs1(int x, int y) { // 第二次搜索
    sea[x][y] = '2';
    int newx, newy;
    For(i, 4) {
        newx = x + next4[i][0], newy = y + next4[i][1];
        if (1 <= newx && newx <= m && 1 <= newy && newy <= n && sea[newx][newy] == '1')
            dfs1(newx, newy);
    }
}
signed main() {
    cin >> t; // 读取测试用例的数量
    while (t--) { // 处理每个测试用例
        int ans = 0; // 用于记录答案的变量，初始化为0
        cin >> m >> n; // 读取海岛地图的行数和列数
        For(i, m + 2) For(j, n + 2) sea[i][j] = '0'; // 初始化海岛地图，将所有位置初始化为字符 '0'
        For1(i, m) For1(j, n) cin >> sea[i][j]; // 读取海岛地图的内容，存储到二维字符数组 sea 中
        dfs(0, 0); // 调用 dfs 函数开始搜索，从位置 (0, 0) 开始
        For1(i, m) For1(j, n) if (sea[i][j] == '0') sea[i][j] = '1'; // 标记未被访问的陆地为已访问，将字符 '0' 替换为字符 '1'
        For1(i, m) For1(j, n) if (sea[i][j] == '1') ans++, dfs1(i, j); // 计数海岛的数量，对每个未被访问的陆地调用 dfs1 函数开始搜索
        cout << ans << endl; // 输出当前测试用例的答案
    }
   return 0;
}

心得体会：

1、if (0 <= newx && newx <= m + 1 && 0 <= newy && newy <= n + 1 && sea[newx][newy] == '0')

这个条件判断语句用于确定新的位置 newx 和 newy 是否满足以下条件：

1）0 <= newx：新的行坐标 newx 大于等于 0，即在地图范围内。

2）newx <= m + 1：新的行坐标 newx 小于等于 m + 1，其中 m 是地图的行数。这个条件确保新的位置在地图的有效行范围内。

3）0 <= newy：新的列坐标 newy 大于等于 0，即在地图范围内。

4）newy <= n + 1：新的列坐标 newy 小于等于 n + 1，其中 n 是地图的列数。这个条件确保新的位置在地图的有效列范围内。

5）sea[newx][newy] == '0'：新的位置上的元素值为字符 '0'，表示该位置是未被访问过的陆地。

如果以上所有条件都满足，即新的位置在地图范围内且为未被访问过的陆地，那么该条件判断为真，执行 dfs(newx, newy);，递归调用 dfs 函数以继续搜索新的位置。否则，如果条件判断为假，则不执行递归调用，结束当前循环，继续下一个方向的搜索。

2、newx = x + next4[i][0], newy = y + next4[i][1];：根据当前位置 (x, y) 和四连通的方向偏移量计算新的位置 (newx, newy)。

• if (1 <= newx && newx <= m && 1 <= newy && newy <= n && sea[newx][newy] == '1')：判断新的位置是否满足以下条件：

  • 1 <= newx：新的行坐标 newx 大于等于 1，即在地图范围内。
  • newx <= m：新的行坐标 newx 小于等于 m，其中 m 是地图的行数。这个条件确保新的位置在地图的有效行范围内。
  • 1 <= newy：新的列坐标 newy 大于等于 1，即在地图范围内。
  • newy <= n：新的列坐标 newy 小于等于 n，其中 n 是地图的列数。这个条件确保新的位置在地图的有效列范围内。
  • sea[newx][newy] == '1'：新的位置上的元素值为字符 '1'，表示该位置是未被访问过的陆地。

• dfs1(newx, newy);：如果以上所有条件都满足，即新的位置在地图范围内且为未被访问过的陆地，那么调用 dfs1 函数以继续搜索新的位置。

3、在二维平面上，四连通性表示一个位置与其上、下、左、右四个相邻位置相连。而八连通性则表示一个位置与其上、下、左、右以及四个对角线方向上的相邻位置相连。在某些算法或问题中，根据具体需求选择不同的连通性可以更好地适应问题的特性和求解目标。

例如，在进行图遍历或搜索算法时，如果问题中只关注上、下、左、右四个方向的连通性，使用四连通性可以简化算法的实现和减少搜索的方向数量，从而提高效率。而在另一些问题中，可能需要考虑到对角线方向上的连通性。比如，在寻找最短路径或连通区域时，八连通性更能全面地考虑到所有可能的路径，以获得更准确的结果

这道题：第一次搜索使用了八连通的方式，通过递归调用 dfs 函数实现。这意味着在搜索过程中，当前位置 (x, y) 的上、下、左、右以及四个对角线方向上的相邻位置都会被考虑到。这种方式可以确保所有与初始位置在八个方向上相连的陆地都会被标记为字符 '2'。

而第二段代码使用了四连通的方式进行搜索，通过循环和递归调用 dfs1 函数实现。在四连通的情况下，只有当前位置 (x, y) 的上、下、左、右四个相邻位置会被考虑到。这样的搜索方式会忽略对角线方向上的相邻位置，只标记与初始位置在四个方向上相连的陆地。

---

蓝桥杯2022年第十三届省赛真题-修剪灌木

题目描述

爱丽丝要完成一项修剪灌木的工作。有 N 棵灌木整齐的从左到右排成一排。爱丽丝在每天傍晚会修剪一棵灌木，让灌木的高度变为 0 厘米。爱丽丝修剪灌木的顺序是从最左侧的灌木开始，每天向右修剪一棵灌木。当修剪了最右侧的灌木后，她会调转方向，下一天开始向左修剪灌木。直到修剪了最左的灌木后再次调转方向。然后如此循环往复。灌木每天从早上到傍晚会长高 1 厘米，而其余时间不会长高。在第一天的早晨，所有灌木的高度都是 0 厘米。爱丽丝想知道每棵灌木最高长到多高。

输入格式

一个正整数 N ，含义如题面所述。

输出格式

输出 N 行，每行一个整数，第i行表示从左到右第 i 棵树最高能长到多高。

样例输入

3

样例输出

4
2
4

提示

对于 30% 的数据，N ≤ 10. 对于 100% 的数据，1 < N ≤ 10000

代码表示

#include <bits/stdc++.h>
using namespace std;

int main(){
	int n;
	cin>>n;
	for(int i=1;i<=n;++i){
		if(i<=n/2){
			cout<<2*n-2*i<<endl;
		}else{
			cout<<2*n-2*(n-i+1)<<endl;
		}
	}
	return 0;
}

心得体会：

可算做出来一道，这道题就是数学问题，找个规律，真希望这届数学问题多一些。

---

蓝桥杯第十三届省赛真题-X进制减法

题目描述

进制规定了数字在数位上逢几进一。X 进制是一种很神奇的进制，因为其每一数位的进制并不固定！例如说某种 X 进制数，最低数位为二进制，第二数位为十进制，第三数位为八进制，则 X 进制数 321 转换为十进制数为 65。

现在有两个 X 进制表示的整数 A 和 B，但是其具体每一数位的进制还不确定，只知道 A 和 B 是同一进制规则，且每一数位最高为 N 进制，最低为二进制。请你算出 A − B 的结果最小可能是多少。

请注意，你需要保证 A 和 B 在 X 进制下都是合法的，即每一数位上的数字要小于其进制。 

输入格式

第一行一个正整数 N，含义如题面所述。

第二行一个正整数 Ma，表示 X 进制数 A 的位数。

第三行 Ma 个用空格分开的整数，表示 X 进制数 A 按从高位到低位顺序各个数位上的数字在十进制下的表示。

第四行一个正整数 Mb，表示 X 进制数 B 的位数。

第五行 Mb 个用空格分开的整数，表示 X 进制数 B 按从高位到低位顺序各个数位上的数字在十进制下的表示。

请注意，输入中的所有数字都是十进制的。

输出格式

输出一行一个整数，表示 X 进制数 A − B 的结果的最小可能值转换为十进制后再模 1000000007 的结果。 

样例输入

11
3
10 4 0
3
1 2 0

样例输出

94

提示

当进制为：最低位 2 进制，第二数位 5 进制，第三数位 11 进制时，减法得到的差最小。此时 A 在十进制下是 108，B 在十进制下是 14，差值是 94。

对于 30% 的数据，N ≤ 10; Ma, Mb ≤ 8. 对于 100% 的数据，2 ≤ N ≤ 1000; 1 ≤ Ma, Mb ≤ 100000; A ≥ B. 

代码表示

#include <bits/stdc++.h>
using namespace std;

int p(int a,int b,int c)//返回三个整数 a、b、c 中的最大值。
{
    return (a>b?a:b)>c?(a>b?a:b):c;
}
int main()
{
//n 表示X进制数A的位数 m 表示X进制数B的位数。
//a 是一个整型数组，用于存储 X 进制数 A 
//按从高位到低位顺序各个数位上的数字在十进制下的表示
    int n,m,l,a[100001],b[100001];
    long long res=0;//存储计算结果
    
    //将数组 a 和 b 的所有元素初始化为 0。
    memset(a,0,sizeof(a));
    memset(b,0,sizeof(b));
    cin>>l;

//for 循环和 cin 逆序输入数组 a[] 的值
    cin>>n;
    for(int i=n;i>0;i--) cin>>a[i];
    
    cin>>m;
    for(int i=m;i>0;i--) cin>>b[i];
    
    for(int i=n;i>1;i--)
    {
        res=( (res+a[i]-b[i]) * p(a[i-1]+1,b[i-1]+1,2) )%1000000007;
    }
    res+=a[1]-b[1];
    cout<<res<<endl;
    return 0;
}

心得体会

1、10 4 0——>10*5*2+4*2=108.

因此A= a[i] * p[r] (r从0到i-1个进制的积)+a[i-1]*p[r-1]+……a[0];
注意事项:

数据非常大，必须边求边累加，直接累加最后相减会出现问题

2、memset 函数将 ptr 指向的内存空间的前 num 个字节都设置为 value。

在代码中的使用示例：

int a[100001];
memset(a, 0, sizeof(a));

这段代码将整型数组 a 的所有元素都设置为 0。通过使用 memset(a, 0, sizeof(a))，可以将数组 a 的内存空间的前 sizeof(a) 个字节都设置为 0。在这个例子中，sizeof(a) 是数组 a 的总字节数，因为 a 是一个数组，它的大小是 100001 个整型元素乘以每个整型元素的字节数（通常是 4 字节）。

3、参数 a[i-1]+1 表示数组 a 中第 i-1 个数位的值加1，而 b[i-1]+1 表示数组 b 中第 i-1 个数位的值加1。这样，函数 p 可以根据前一位数位的值加1来考虑进位的情况。