[NOIP 2002普及组]产生数（floyd+高精度）

https://www.luogu.org/problem/P1037

题目描述

给出一个整数 n（n<10³⁰) 和 k 个变换规则（k<=15）。
规则：
一位数可变换成另一个一位数：规则的右部不能为零。
例如：n=234。有规则（k＝2）：
2－> 5
3－> 6
上面的整数 234 经过变换后可能产生出的整数为（包括原数）:
234
534
264
564
共 4 种不同的产生数
问题：
给出一个整数 n 和 k 个规则。
求出：
经过任意次的变换（0次或多次），能产生出多少个不同整数。仅要求输出个数。

输入描述:

输入格式为：
n k

x₁ y₁

x₂ y₂

... ...

x_n y_n

输出描述:

一个整数（满足条件的个数）

示例1

输入

234 2
2 5
3 6

输出

 4

多给一组数据吧，我第一次写的就这个没过

输入

12345678901234567890 9
2 1
3 2
4 3
5 4
6 5
7 6
8 7
9 8
0 9

输出

13168189440000

注意点：

1、一共有15种操作  说明一个数可以变成多个不同的数

如果存在 2个操作 a->b   b->c   则a既可以变到b也可以变到c

所以可以通过DFS或floyd求出每个数字可以变成多少种数字

2、最多可能有30位数 所以最大可能9^30

需要模拟大数乘法 而每次乘数有一个 不超过10 所以并不难

故floyd+高精度秒杀,用floyd求出每个数字可以变成多少种数字,然后乘起来

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <string>
#include <math.h>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <math.h>
const int INF=0x3f3f3f3f;
typedef long long LL;
const int mod=1e9+7;
const double PI=acos(-1);
const int maxn=100010;
using namespace std;
//ios::sync_with_stdio(false);
//    cin.tie(NULL);

int k;
char str[50];
int tag[10][10];//tag[i][j]=1代表数字i可变成j 
int num[10];//存放每个数字可变换数字的个数 
int ans[1000];//答案 

int main()
{
    scanf("%s %d",str,&k);
    for(int i=1;i<=k;i++)
    {
        int a,b;
        scanf("%d %d",&a,&b);
        tag[a][b]=1; 
    }
    for(int k=1;k<=9;k++)//floyd 
    {
        for(int i=0;i<=9;i++)
        {
            for(int j=0;j<=9;j++)
            {
                if(tag[i][k]&&tag[k][j])
                    tag[i][j]=1;
            }
        }
    }
    for(int i=0;i<=9;i++)
    {
        tag[i][i]=1;
        for(int j=0;j<=9;j++)
        {
            if(tag[i][j])
                num[i]++;
        }
    }
    //高精度乘法 
    ans[0]=1;//初始答案 
    int jinwei;//进位 
    int weishu=1;//位数 
    for(int i=0;str[i];i++)
    {
        jinwei=0;
        int x=num[str[i]-'0'];//该位置数字可变多少种数字 
        for(int j=0;j<weishu;j++)
        {
            int t=ans[j]*x+jinwei;
            ans[j]=t%10;
            jinwei=t/10;
        }
        while(jinwei)
        {
            ans[weishu++]=jinwei%10;
            jinwei/=10;
        }
    }
    for(int i=weishu-1;i>=0;i--)//注意要反着输出 
    {
        printf("%d",ans[i]);
    }
    printf("
");
    return 0;
}

下面粘另一种写法，主要用了DFS，复杂度可能小一点（from：https://blog.csdn.net/AXuan_K/article/details/41479705）

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int op[10][10];           
char str[105];
int vis[10];
int value[32];
int maxlen=1;
void dfs(int a)         //搜索出每个数可以到达的数的个数   用SS保存
{
    if(vis[a])
        return;
    vis[a]=1;
    ss++;
    for(int i=0;i<=9;i++)
    {
        if(op[a][i]==1)
            dfs(i);
    }
}
void multiple(int x)             //最大可能 9^30 超long long  所有模拟大数乘法
{
    int carry=0;                 //carry表示进位
    for(int i=1;i<=maxlen;i++)
    {
        value[i]=value[i]*x+carry;
            carry=value[i]/10;
            value[i]=value[i]%10;
    }
    if(carry>0)               
        value[++maxlen]=carry;
    return;
}
int main()
{
    int m,n,i,j,k;
    int s;
    value[1]=1;
    memset(op,0,sizeof(op));
    scanf("%s%d",str,&k);
    int a,b;
    if(k==0)               
    {
        cout<<1<<endl;
        return 0;
    }
    while(k--)
    {
        scanf("%d%d",&a,&b);
        op[a][b]=1;               //op[a][b]代表a可以到b
    }
    int len=strlen(str);
    for(i=0;i<len;i++)
    {
        memset(vis,0,sizeof(vis));
        ss=0;
        dfs(str[i]-'0');          //求出每位可转换数的乘积   //其实可以用一个数组保存每个数可转换的数的个数  
        multiple(ss);
    }
    for(i=maxlen;i>=1;i--)
        cout<<value[i];
    cout<<endl;
    return 0;
}