提交链接：hiho1251


现场赛的时候这个题过题率特别特别低，原因是搞不懂这个题的正确姿势

现在想想，数据规模特别小的时候，暴力就是最好的姿势


题意：给两个只有1，2，3，4，5，6的数字串，操作A修改某一个字符，操作B为修改某一类字符，问最少多少次操作可以把第二个串变成第一个

题目的两种操作：我们可以知道，需要建立一个一一的对应关系：

1变成什么，2变成什么？这样会有123456对应到abcdef的情况

考虑到修改某一类字符，肯定是先刷一层，再去刷下一层，所以我们可以用状态压缩，然后暴力枚举出来所有情况

把123456变成012345，然后bfs，考虑出来所有的变化情况


然后，把两个串的值统计一下，然后暴力枚举：

从s2到中间串，中间串到s1需要多少步骤，取个最小值就好了


另外，解释下maxm是个啥：

从000000到555555的六进制表示法，所以呢：计算得到一个状态压缩的整数


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

const int maxn=5e4+50;
const int maxm=46656;
const int INF=0x3f3f3f3f;

char s1[200],s2[200];
int dp[maxn],g[10][10],cnt[10];

int idx(int c[]){
    int ret=0;
    for(int i=0;i<6;i++)
        ret=ret*6+c[i];
    return ret;
}

void ridx(int s,int c[]){
    for(int i=5;i>=0;i--){
        c[i]=s%6;
        s/=6;
    }
}

//123456
//abcdef
//产生这样的一一对应，需要花费多少次刷子（操作2）

void presolve(){
    queue<int> Q;
    memset(dp,INF,sizeof(dp));
    int c[]={0,1,2,3,4,5},id=idx(c);
    dp[id]=0;
    Q.push(id);
    while(!Q.empty()){
        int f=Q.front(),d[10];
        Q.pop();
        ridx(f,c);
        for(int i=0;i<6;i++)
        for(int j=0;j<6;j++){
            memcpy(d,c,sizeof(c));
            for(int k=0;k<6;k++)
                if (c[k]==i) d[k]=j;
            id=idx(d);
            if (dp[id]==INF){
                dp[id]=dp[f]+1;
                Q.push(id);
            }
        }
    }
}

int main(){
    //freopen("input.txt","r",stdin);
    presolve();
    while(scanf("%s%s",s1,s2)!=EOF){
        memset(g,0,sizeof(g));
        memset(cnt,0,sizeof(cnt));
        int len=strlen(s1);
        for(int i=0;i<len;i++){
            int u=s2[i]-'1';
            int v=s1[i]-'1';
            g[u][v]++;
            cnt[u]++;
        }
        int ans=INF,c[10];
        for(int s=0;s<maxm;s++){
            ridx(s,c);
            int sum=dp[s];
            for(int i=0;i<6;i++)
                sum+=cnt[i]-g[i][c[i]];
            ans=min(ans,sum);
        }
        printf("%d\n",ans);
    }
    return 0;
}