011 You Are Given a Decimal String...（CF1202B）

原题链接：[CF1202B](https://codeforces.com/contest/1202/problem/B)
标签：暴力、dp、最短路
大意：有一个x-y counter，对已有的数随机地加x或y，输出个位，多次操作后得到一串数样例如下：

对于2-4counter
1.0+4=4，输出04；
2.4+4=8，输出048
3.8+4=12，输出0482
4.2+2=4，输出04824
5.4+4=8，输出048248

当然以上只是2-4counter的一个可能的情况，因为加2加4完全是随机的。
现给出一串数，对于i-j counter,若（0<=i,j<=9,i,j均为整数），往给定数组中添加若干个数，使该数组成为i-jcounter的一种可能输出，求需补充的数的最小值，（不可能输出-1）输出格式如下：
（i行j列代表i-j counter）

-1 17 7 7 7 -1 2 17 2 7 
17 17 7 5 5 5 2 7 2 7 
7 7 7 4 3 7 1 7 2 5 
7 5 4 7 3 3 2 5 2 3 
7 5 3 3 7 7 1 7 2 7 
-1 5 7 3 7 -1 2 9 2 7 
2 2 1 2 1 2 2 2 0 1 
17 7 7 5 7 9 2 17 2 3 
2 2 2 2 2 2 0 2 2 2 
7 7 5 3 7 7 1 3 2 7

思路：
①由于数字的范围很小，bfs对每个i-jcounter对应的情况求最小步数，可直接搜出答案：

#include 
#include 
#include 
#include 
using namespace std;
 
struct node
{
	int x, step;
	node(int _x,int _step) : x(_x), step(_step){}
};
 
string s;
int Time[10][10][10][10], vis[10]; //Time[i][j][x][y]表示用i，j两个数字使得x变为y的最小次数，加任意数10次都会回到原点 
 
void bfs(int x,int y,int s) //x-y counter 从s起达到各个数需要的最小步数 
{
	memset(vis,0,sizeof(vis));
	queue  q;
	node now(s,0);
	q.push(now);
	while(!q.empty())
	{
		node t = q.front(); 
		q.pop();
		if(!vis[(t.x+x)%10]) //(t.x+x)%10表示目前加到的这个数的余数、此if为加x 
		{
			vis[(t.x+x)%10] = 1;
			Time[x][y][s][(t.x+x)%10]=t.step+1;
			q.push(node{(t.x+x)%10,t.step+1});
		}
		if(!vis[(t.x+y)%10])//此if表示加y 
		{
			vis[(t.x+y)%10]=1;
			Time[x][y][s][(t.x+y)%10]=t.step+1;
			q.push(node{(t.x+y)%10,t.step+1});
		}
	}
}
 
int main()
{
	memset(Time,-1,sizeof Time);
	for(int i = 0; i < 10; ++i)
		for(int j = 0; j < 10; ++j) //存在对称性，可以节省时间
			for(int k = 0; k < 10; ++k)
				bfs(i,j,k);
	cin>>s;
	int len = s.length();
	for(int i = 0; i < 10; ++i)
	{
		for(int j = 0; j < 10; ++j)
		{
			int ans = 0;
			for(int k = 1; k < len; ++k)
			{
				if(Time[i][j][s[k-1]-'0'][s[k]-'0'] == -1)//若不能到达，即值为-1 
				{
					ans = -1; break;
				}
				ans += Time[i][j][s[k-1]-'0'][s[k]-'0'];
			}
			if(ans == -1)
				cout<

②应用最短路
首先按照上法，对每个x-y counter进行处理，每次选择x，y，代表每次可以走x或y的距离，那么可以用弗洛伊德算法处理一下0~9之间的最短路，再遍历一次数字串，计算每两个数字的最短路，如果走不到就说明在x-y counter下不能走到，输出-1；

下面先简单补充一下Floyd算法，就是枚举所有的可能，于是就知道两点间的最短路。
我们从一个点i到另一个点j,无非就两种走法

• 直接从i走到j
• 先从i走到k，再从k走到j
  本题也是，先求出一步能实现的变换，再借助上述思想对多步才能走到的情况进行拓展
  代码如下：

#include 
using namespace std;
const int maxn=2e6+10;
typedef  long long ll;
const int inf=0x3f3f3f3f; 
int dis[10][10];//dis[i][j]记录 i到j的最短路 
char s[maxn];
int n;
int fun(int x,int y)//找出x-y counter 所需的最小步 
{
    memset(dis,inf,sizeof(dis));
    for(int i=0;i<10;i++)
	{
        dis[i][(i+x)%10]=dis[i][(i+y)%10]=1;//一步到达的情况 
    }
    for(int k=0;k<10;k++)
	{
        for(int i=0;i<10;i++)
		{
            for(int j=0;j<10;j++)
			{
                dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);//某点分解成i->k->j; 
            }
        }
    }
    ll ans=0;
    for(int i=0;i