洛谷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

样例输出1

题解

这个问题我们可以转换成图论里面的问题。

我们可以把 \(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;

}