洛谷P1037 产生数 题解 搜索
题目链接：https://www.luogu.com.cn/problem/P1037
题目描述
给出一个整数 \(n(n<10^{30})\) 和 \(k\) 个变换规则 \((k \le 15)\) 。
规则：
一位数可变换成另一个一位数：
规则的右部不能为零。
例如：\(n=234\)。有规则（\(k=2\)）：
\(2\)－>\(5\)
\(3\)－>\(6\)
上面的整数\(234\)经过变换后可能产生出的整数为（包括原数）:
\(234\)
\(534\)
\(264\)
\(564\)
共 \(4\) 种不同的产生数
问题：
给出一个整数 \(n\) 和 \(k\) 个规则。
求出：
经过任意次的变换（\(0\)次或多次），能产生出多少个不同整数。
仅要求输出个数。
输入格式
键盘输入，格式为：
\(n\) \(k\)
\(x_1\) \(y_1\)
\(x_2\) \(y_2\)
... ...
\(x_n\) \(y_n\)
输出格式
屏幕输出，格式为：
\(1\) 个整数（满足条件的个数）
样例输入1
234 2
2 5
3 6
样例输出1
4
题解
这个问题我们可以转换成图论里面的问题。
我们可以把 \(0\) 到 \(9\) 这 \(10\) 个数看成 \(10\) 个点。
然后对于任意一对关系 \(x\) -> \(y\) ，我们从 \(x\) 向 \(y\) 连一条边。
那么我们怎么存这个图呢？
图论里面最基础的存图方式是 邻接矩阵 和 邻接表 。
邻接矩阵 的方法：
我们开一个 \(10 \times 10\) 的数组 \(g[10][10]\) ，
一开始置所有的 \(g[i][j]\) 为 \(false\)，
然后如果有一对关系 \(x\) -> \(y\) ，则令 \(g[x][y]\) 为 \(true\)。
这样操作之后，我就知道对于任意一个数 \(x\) ，它能够直接到达的数的个数，即：所有 \(g[x][j]\) 为 \(true\) 的数的个数。
我们这里说的是 \(x\) 到 \(y\) 能直接到达是指 \(x\) 到 \(y\) 有一条直接可达的边（即 \(g[x][y] = true\)）。
但是除了直接可达以外，还有间接可达的，比如，如果有两对关系：
\(1\) -> \(2\)
\(2\) -> \(3\)
那么 \(1\) 是可以通过 \(2\) 间接到达 \(3\) 的。
那么怎么确定每一个数可达的数的范围呢？比较方便的形式就是 搜索。
我们再开一个bool数组 \(vis[10][10]\) ，\(vis[x][y]\) 用于标记 \(x\) 到 \(y\) 是否可达（包括直接或间接可达）；
然后开一个函数 dfs(int u, int s) ，其中 \(u\) 表示当前点， \(s\) 表示起点，如果当前到达点 \(u\) ，则置 \(vis[s][u]\) 为 \(true\)，然后对于所有 u 直接可达的点 v ，执行 dfs(v, s)（但是要注意，如果此时 \(vis[s][v]\) 为 \(true\) ，则不需要访问了，因为递归的访问访问过的点会致使函数陷入死循环）。
实现的伪代码如下（伪代码就是不可以编译的代码，但是你可以看懂的代码）：
dfs(u, s):
vis[s][u] = true;
for 所有u能够直接到达的v:
if (v没有访问过):
dfs(v, s);
但是这里遇到一个问题，这个问题是邻接矩阵的效率问题，这个问题体现在：
如果现在有 \(10\) 对关系：
\(0\) -> \(1\)
\(1\) -> \(2\)
... ...
\(8\) -> \(9\)
那么如果一开始从 \(0\) 开始搜索，会搜索 \(10\) 层，在每一层，对于当前 dfs(u, s) 中的 \(u\) ，我们需要从 \(0\) 到 \(9\) 遍历 \(v\) ，所以总共需要进行 \(10^{10}\) 次判断。
而这个时间是不允许的（一道题的时间复杂度不能超过 \(10^9\)）！
因为邻接矩阵中存在很多多余的判断，对于任意一个 \(u\) ，你需要从 \(0\) 到 \(9\) 去遍历 \(i\) 并判断 \(g[u][i]\) 是否为 \(true\)，来确定 \(u\) 到 \(i\) 是否有一条边。这样就有着很多多余的判断。
那么是否能够对于每一个点 \(u\) ，我们都用一个东西记录和它邻接的点（即：它能够到达的点）有哪些呢？
实现的方式有两种：
- 链表（链表刚好可以实现这个功能）
- 可变数组。
邻接表 的方法：
我们在这里使用 STL （C++标准库）中提供给我们的 vector 容器来实现这个功能。
vector 容器提供给我们的功能就是可变数组的功能。
使用 vector 之前需要添加头文件：
#include <vector>
当然这个头文件也是包含在万能头文件中的。
我们可以通过下面的代码来体会一下 vector 的使用：
#include <bits/stdc++.h>
using namespace std;
vector<int> vec; // 定义一个int类型的可变数组vec
int main() {
for (int i = 1; i <= 5; i ++)
vec.push_back(i); // vec内一次push进去1至5
cout << vec.size() << endl; // vec的大小
for (int i = 0; i < 5; i ++)
cout << vec[i] << ","; // 通过vec[i]获取vec的第i个元素，坐标同样从0开始
return 0;
}
输出结果如下：
5
1,2,3,4,5,
那么我们可以开一个 vector<int> 类型的数组 \(g[10]\) ，然后对于每一对关系 \(x\) -> \(y\) ，执行：
g[x].push_back(y);
然后想要知道点 \(x\) 有哪些直接可达的点 \(y\) ，可以这样遍历：
for (int i = 0; i < g[x].size(); i ++) {
int y = g[x][i];
}
但是以我多年的经验，每次执行 g[x].size() 效率比较低，所以我们可以一开始开一个变量 sz 来存放 g[x].size() ，然后再进行遍历，实现代码如下：
int sz = g[x].size();
for (int i = 0; i < sz; i ++) {
int y = g[x][i];
}
这样我们就大致讲解好了 邻接表 的 vector 实现。
然后我们再开一个 \(cnt\) 数组， \(cnt[x]\) 表示 \(x\) 能够达到的数的数量。
对于我们的样例：
因为 \(2\) 能够到达 \(5\) ， \(3\) 能够到达 \(6\) ，所以：
\(cnt[2]=2\)
\(cnt[3]=2\)
其它的 \(cnt\) 值都为 \(1\) 。
所以对于 \(234\) 来说，总的方案数为：
\(cnt[2] \times cnt[3] \times cnt[4] = 2 \times 2 \times 1 = 2\)。
因为数据量达到了 \(10^{30}\) ，用 long long 也存不下，所以得使用高精度乘法（我的代码里面实现了一个很简单的高精度乘法）。
然后我们结合上面讲到的 dfs 函数，可以实现代码如下：
#include <bits/stdc++.h>
using namespace std;
char s[33];
int len, ans[33], k, x, y, cnt[10];
bool vis[10][10];
vector<int> g[10];
void dfs(int u, int s) {
vis[s][u] = true;
int sz = g[u].size();
for (int i = 0; i < sz; i ++) {
int v = g[u][i];
if (!vis[s][v])
dfs(v, s);
}
}
void multi(int a) { // 实现大数和小数的乘法
for (int i = 0; i < 33; i ++)
ans[i] *= a;
for (int i = 0; i < 32; i ++) {
ans[i+1] += ans[i]/10;
ans[i] %= 10;
}
}
void output() { // 输出结果
int i = 32;
while (i > 0 && ans[i] == 0) i --;
while (i >= 0) cout << ans[i--];
cout << endl;
}
int main() {
cin >> s >> k;
while (k --) {
cin >> x >> y;
g[x].push_back(y);
}
for (int i = 0; i < 10; i ++)
dfs(i, i);
for (int i = 0; i < 10; i ++)
for (int j = 0; j < 10; j ++)
cnt[i] += vis[i][j];
ans[0] = 1;
int len = strlen(s);
for (int i = 0; i < len ; i ++)
multi(cnt[ s[i]-'0' ]);
output();
return 0;
}
