hihicoder 1251

Today is a rainy day. The temperature is apparently lower than yesterday. Winter is coming. It always
leaves people feeling fatigued and tired.
Lee hasn’t prepared for winter yet. As he wakes up this morning, he looks out of the window.
Yesterday’s shining sunlight can no longer be seen. It is dark outside. The sky looks so heavy that it
may collapse down at any moment. Lee gets out of his bed, shakes his head slightly to make himself
more awake. But it’s of no use for him. Then he goes to the restroom and washes up.
Lee has a class in fifteen minutes. If he sets out immediately, he may gets to the classroom on time.
But he is not in the mood to do so. He decides to skip class and does something more interesting to
train his mind.
He takes out a draft paper and writes a list of digits using a dice. It is obvious that the digits are
all between 1 and 6. And then he applies two kind of modifications to the digits. The first kind is
to modify one digit into another. The second kind is to modify one kind of digits into another. For
example, he can modify “12123” to “12121” using the first kind of modification, or modify “12123” to
“13133” using the second kind of modification. In the process of modification, all digits should be in
{1, 2, 3, 4, 5, 6};
After a few modifications, he feels tired but pleased. He’s got a list of digits which is very different
from the original one. Thinking of the next thing to do, Lee becomes a little excited. He is going to
figure out the least number of modifications to transform the final list back to the original one using
the same rules.
Lee made it in a very short time. Can you do this like him?
Input
There are up to 100 test cases.
For each test case, there are two lines containing two lists of digits, representing the original list
and the final list in order. The digits are all between 1 and 6. It is guaranteed that two lists are of
same length. The length will not be greater than 110.
Output
For each test case, output one integer, the answer.
Sample Input
22345611
12345611
2234562221
1234561221
2234562211
1234561111
22345622112
12345611111
654321654321654321654321
123456123456123456123456
Sample Output
1
2
3
3

11

 参考http://www.cnblogs.com/Running-Time/p/4978097.html

题意：一串数字变成另一串数字，可以单个数字转变，或者一类数字转变，问最少操作次数
分析：首先一类转换比单个转换优，先枚举找出最优的映射方案，然后将零碎的操作加上。6位6进制表示map映射，比如123456，表示map[1] = 1, map[2] = 2, map[3] = 3...
先预处理出每种方案的的操作数，用BFS+dp写，然后暴力枚举取最小值

#include
#include
#include
#include
#include
using namespace std;
const int inf=0x7f7f7f7f;
const int maxn=120;
const int maxm=5e4+5;
char a[maxn],b[maxn];
int dp[maxm],cnt[6],g[6][6];
int idx(int *c)
{
	int tmp=0;
	for(int i=0;i<6;i++)
	tmp=tmp*6+c[i];
	return tmp;
}
void ridx(int x,int *c)
{
	for(int i=5;i>=0;i--)
	{
		c[i]=x%6;
		x=x/6;
	}
}
void bfs()
{
	memset(dp,inf,sizeof(dp));
	int c[6];
	for(int i=0;i<6;i++) c[i]=i;
	int s=idx(c);
	dp[s]=0;
	queueque;
	que.push(s);
	while(!que.empty())
	{
		int u=que.front();
		que.pop();
		ridx(u,c);
		for(int i=0;i<6;i++)
		{
			for(int j=0;j<6;j++)
			{
				int t[6];
				memcpy(t,c,sizeof(t));
				for(int k=0;k<6;k++)
				if(t[k]==i) t[k]=j;
				int v=idx(t);
				if(dp[v]>dp[u]+1)
				{
					dp[v]=dp[u]+1;
					que.push(v);
				}
			}
		}
	}
}
int main()
{
	bfs();
	while(scanf("%s%s",a,b)!=EOF)
	{
		int len=strlen(a);
		memset(cnt,0,sizeof(cnt));
		memset(g,0,sizeof(g));
		for(int i=0;i