图形变换问题

图形变换问题

Description

给定2 个4*4 方格阵列组成的图形A 和B，每个方格的颜色为黑色或白色。方格阵列
中有公共边的方格称为相邻方格。图形变换问题的每一步变换可以交换相邻方格的颜色。试
设计一个算法，计算最少需要多少步变换，才能将图形A变换为图形B。

编程任务：
对于给定的2 个方格阵列，编程计算将图形A变换为图形B的最少变换次数。

Input

由文件input.txt 给出输入数据。前4 行是图形A 的方格阵列，后4 行是图形B 的方格
阵列。0 表示白色，1表示黑色。

Output

将计算出的最少变换次数和相应的变换序列输出到文件output.txt。第1 行是最少变换
次数。从第2 行开始，每行用4 个数表示一次变换。例如，1112 表示交换方格（1，1）和
（1，2）的颜色。问题无解时输出“No solution!”

Sample Input

1010
0100
0010
1010
0110
0001
0010
1010

Sample Output

最少需要3步:
第1步:
0 1 1 0
0 1 0 0
0 0 1 0
1 0 1 0
第2步:
0 1 1 0
0 0 1 0
0 0 1 0
1 0 1 0
第3步:
0 1 1 0
0 0 0 1
0 0 1 0
1 0 1 0

my_Code

#include<iostream>
#include<queue>
using namespace std;
const maxsize=1<<16;
int a[maxsize],b[maxsize];
int sour,dest;
char map[4][4];
// 广度优先搜索
bool solve(void)
{
int i,j;
int c1,c2;
int state1,state2;
queue<int> qu;
a[sour]=0;
qu.push(sour);
while(!qu.empty())
{
   state1=qu.front();
   qu.pop();
   // 左右交换得到新的状态
   for(i=0; i<4; i++)
   {
    for(j=0; j<3; j++)
    {
     c1=1<<(i*4+j);
     c2=1<<(i*4+j+1);
    
     if ( (state1 & c1 ) != (state1 & c2) )
     {
      state2=state1;
     
      state2^=c1;
      state2^=c2;
      if(a[state2]==-1)
      {
       a[state2]=a[state1]+1;
       b[state2]=(i*4+j)+1;       // 正数表示左右交换,记录右边那个元素
       if(state2==dest)
        return true;
       qu.push(state2);
      }
     }
    }
   }
   // 上下交换得到新的状态
   for(i=0; i<3; i++)
   {
    for(j=0; j<4; j++)
    {
     c1=1<<(i*4+j);
     c2=1<<(i*4+j+4);
     if ( (state1 & c1 ) != (state1 & c2) )
     {
      state2=state1;
     
      state2^=c1;
      state2^=c2;
      if(a[state2]==-1)
      {
       a[state2]=a[state1]+1;
       b[state2]=-(i*4+j)-4;    // 负数表示上下交换，记录下边那个元素
       if(state2==dest)
        return true;
       qu.push(state2);
      }
     }
    }
   }
}
return false;
}
// 显示方格图形
void print(void)
{
int i,j;
for(i=0; i<4; i++)
{
   for(j=0; j<4; j++)
   {
    cout<<map[i][j]<<" ";
   }
   cout<<endl;
}
}
// 递归打印每一步骤
void output(int state,int step)
{
if(state!=sour)
{
   int c1,c2;
   int tmp_state;
   if(b[state]>0)    // 此状态有左右交换而来
   {
    c1=1<<(b[state]-1);
    c2=1<<b[state];

    tmp_state=state;
    tmp_state^=c1;
    tmp_state^=c2;
    output(tmp_state,step-1);

    c1=(b[state]-1)/4;
    c2=(b[state]-1)%4;
   // cout<<c1<<c2<<c1<<c2+1<<endl;
    cout<<"第"<<step<<"步:"<<endl;
    swap(map[c1][c2],map[c1][c2+1]);
    print();
   }
   else          // 此状态由上下交换而来
   {
    b[state]=-b[state];

    c1=1<<(b[state]-4);
    c2=1<<b[state];

    tmp_state=state;
    tmp_state^=c1;
    tmp_state^=c2;
    output(tmp_state,step-1);

    c1=(b[state]-4)/4;
    c2=(b[state]-4)%4;
   // cout<<c1<<c2<<c1+1<<c2<<endl;
    cout<<"第"<<step<<"步:"<<endl;
    swap(map[c1][c2],map[c1+1][c2]);
    print();

    b[state]=-b[state];
   }
}
}
// 主函数
int main(void)
{
int i;
char ch;
sour=0;
for(i=0; i<16; i++)
{
   cin>>ch;
   map[i/4][i%4]=ch;

   sour|=(int)(ch-'0')<<i;
}
dest=0;
for(i=0; i<16; i++)
{
   cin>>ch;
   dest|=(int)(ch-'0')<<i;
}
for(i=0 ;i<maxsize; i++)
{
   a[i]=-1;
}
solve();
if(a[dest]!=-1)
{
   cout<<"最少需要"<<a[dest]<<"步:"<<endl;
   output(dest,a[dest]);

}
return 0;
}