[ACM_搜索] ZOJ 1103 || POJ 2415 Hike on a Graph (带条件移动3盘子到同一位置的最少步数 广搜）

Description

"Hike on a Graph" is a game that is played on a board on which an undirected graph is drawn. The graph is complete and has all loops, i.e. for any two locations there is exactly one arrow between them. The arrows are coloured. There are three players, and each of them has a piece. At the beginning of the game, the three pieces are in fixed locations on the graph. In turn, the players may do a move. A move consists of moving one's own piece along an arrow to a new location on the board. The following constraint is imposed on this: the piece may only be moved along arrows of the same colour as the arrow between the two opponents' pieces.

In the sixties ("make love not war") a one-person variant of the game emerged. In this variant one person moves all the three pieces, not necessarily one after the other, but of course only one at a time. Goal of this game is to get all pieces onto the same location, using as few moves as possible. Find out the smallest number of moves that is necessary to get all three pieces onto the same location, for a given board layout and starting positions.

Input

The input contains several test cases. Each test case starts with the number n. Input is terminated by n=0. Otherwise, 1<=n<=50. Then follow three integers p1, p2, p3 with 1<=pi<=n denoting the starting locations of the game pieces. The colours of the arrows are given next as a m×m matrix of whitespace-separated lower-case letters. The element mij denotes the colour of the arrow between the locations i and j. Since the graph is undirected, you can assume the matrix to be symmetrical.

Output

For each test case output on a single line the minimum number of moves required to get all three pieces onto the same location, or the word "impossible" if that is not possible for the given board and starting locations.

Sample Input

3 1 2 3
r b r
b b b
r b r
2 1 2 2
y g
g y
0

Sample Output

2
impossible

Source

Ulm Local 2000

 

题目大意：有一张图，上面的路径都是着色的，开始的时候有3个盘子在确定的点上，现在让你按要求沿图中的路径移动盘子（一步只能移动一只盘子），问是否能将3个盘子都移到同一个点上，如果可以，输出需要的最少步数，否则输出“impossible”。>_<移动条件是：每个盘子只能沿着这样一条路移动，这条路的颜色和另外的两个盘子之间的路径上标记的颜色是一样的。
解题思路：因为这道题给的是完全图，也就是说图上每两个点之间都有路径存在，它们标记的都有颜色。所以直接BFS就AC啦！
相关链接：过程详解 http://www.cnblogs.com/pcoda/archive/2012/09/02/2667987.html

 #include<iostream>
 #include<queue>
 #include<string>
 #include<string.h>
 using namespace std;
 int n,p1,p2,p3;
 char  map[][];//存储图
 int ans[][][];//保存a[i][j][k]表示3个盘子在i,j,k位置时的最小步数
 int ok;//记录最终3个盘子的位置，如果为0则imposible
 struct state{
     int a,b,c;
 }temp;//3个盘子的位置
 void read(){
     cin>>p1>>p2>>p3;
     for(int i=;i<=n;i++){
         map[i][]='#';//在这填充个字符，不然就报错
         for(int j=;j<=n;j++)
             cin>>map[i][j];
         map[i][n+]='\0';//在行尾加一个结束符，便于后面操作
     }
 }
 void bfs(){
     ok=;
     fill(&ans[][][],&ans[][][]+**,);//将ans初始化很大
     ans[p1][p2][p3]=;//令刚开始位置为0（不要少了）
     queue<state> Q;
     temp.a=p1;temp.b=p2;temp.c=p3;
     Q.push(temp);
     while(!Q.empty()){
         state top=Q.front();Q.pop();
         int x=top.a,y=top.b,z=top.c;
         if(x==y && y==z){//如果3盘到一点就跳出
             ok=x;
             break;
         }else{
             int cur_ans=ans[x][y][z];
             cur_ans++;

             char bc_color=map[y][z];
             string str_a=map[x];//(与a连的所有路径)
             for(int i=;i<=n;i++){
                 //遍历所有路径，如果不是自己，且满足移动条件，且ans[i][y][z]>cur_ans就移动
                 if(i!=x && str_a[i]==bc_color && ans[i][y][z]>cur_ans){
                     ans[i][y][z] = cur_ans;
                     temp.a=i;temp.b=y;temp.c=z;
                     Q.push(temp);
                 }
             }//a盘的移动

             char ac_color=map[x][z];
             string str_b=map[y];
             for(int i=;i<=n;i++){
                 if(i!=y && str_b[i]==ac_color && ans[x][i][z]>cur_ans){
                     ans[x][i][z]=cur_ans;
                     temp.a=x;temp.b=i;temp.c=z;
                     Q.push(temp);
                 }
             }//b盘的移动

             char ab_color=map[x][y];
             string str_c=map[z];
             for(int i=;i<=n;i++){
                 if(i!=z && str_c[i]==ab_color && ans[x][y][i]>cur_ans){
                     ans[x][y][i]=cur_ans;
                     temp.a=x;temp.b=y;temp.c=i;
                     Q.push(temp);
                 }
             }//c盘的移动
         }
     }
 }
 int main(){
     while(cin>>n && n){
         read();
         bfs();
         if(ok)cout<<ans[ok][ok][ok]<<'\n';
         else cout<<"impossible\n";
     }return ;
 }