UVA1601-双向广度优先搜索

 #include <iostream>
 #include <cstdio>
 #include <queue>
 #include <cstring>
 using namespace std;

 int w, h, n, s[], t[];
 char dataset[][];
 int G[][], vis[][][], dist[][][];
 int deg[];
 int dx[] = {, -, , , };//这里包含了不移动的情形
 int dy[] = {, , , -, };

 inline int ID(int a, int b, int c)
 {
     return (a << ) | (b << ) | c;
 }//一种看起来屌炸天的数据整合方式

 inline bool conflict(int a, int b, int a2, int b2)
 {
     return ((a2 == b2) || (a == b2 && b == a2));
     //前者是两者运动到同一位置,后者是两者同时交换位置
 }

 int bfs()
 {
     queue<int> q;
     q.push(ID(s[], s[], s[]));
     dist[s[]][s[]][s[]] = ;//dist初始值是-1，这里的0是做标记
     while(!q.empty())
     {
         int u = q.front();  q.pop();
         int a = (u >> ) & 0xff, b = (u >> ) & 0xff, c = u & 0xff;
         //一种看起来屌炸天的数据整合方式，记住!!
         if(a == t[] && b == t[] && c == t[]) return dist[a][b][c];
         //a对应了main中的cnt编号，它并没有直接验证横竖坐标而是验证了其编号
         for(int i = ; i < deg[a]; i++)
         {//deg[a]是cnt编号为a的字母在该点的所有可行的运动方向的个数,遍历所有可行方向
             int a2 = G[a][i];
         //cnt编号为a的字母运动结果a2
             for(int j = ; j < deg[b]; j++)
             {
                 int b2 = G[b][j];
         //cnt编号为b的字母运动结果b2
                 if(conflict(a, b, a2, b2))continue;
                 //对于产生的运动冲突,由第二个字母做出变换方向的让步
                 for(int k = ; k < deg[c]; k++)
                 {
                     int c2 = G[c][k];
         //cnt编号为c的字母运动结果c2
                     if(conflict(a, c, a2, c2) || conflict(b, c, b2, c2))continue;
                     if(dist[a2][b2][c2] == -)
                     {
                         dist[a2][b2][c2] = dist[a][b][c] + ;
                         //这是记录步数
                         q.push(ID(a2, b2, c2));
                     }
                 }
             }
         }
     }
     return -;
 }

 int main() {
     //freopen("input.txt", "r", stdin);
     while(~scanf("%d%d%d\n", &w, &h, &n) && n)
     {
         for(int i = ; i < h; i++)  fgets(dataset[i], , stdin);
         //输入图
         int cnt = , x[], y[], id[][];
         for(int i = ; i < h; i++)
         for(int j = ; j < w; j++)
         {
             if(dataset[i][j] != '#')//对于所有的可行动的位置都由一个cnt编号
             {
                 //s->cnt->x与y 这是一种值得借鉴的对应关系
                 x[cnt] = i; y[cnt] = j; id[i][j] = cnt;//在图中赋予可行动位置唯一的id
                 if(islower(dataset[i][j]))  s[dataset[i][j] - 'a'] = cnt;
                 else if(isupper(dataset[i][j])) t[dataset[i][j] - 'A'] = cnt;
                 cnt++;//所有的坐标均被分配到x与y数组中,cnt是唯一的确认,将两个数据映射成了一个数据!!!
             }//记录bfs路径的起点与终点的信息 s数组是起点，t数组是终点，
         }
         for(int i = ; i < cnt; i++)//对应每一个位置
         {
             deg[i] = ;
             for(int j = ; j < ; j++)//对应不同的方向且考虑了不移动的情形
             {
                 int nx = x[i] + dx[j];  int ny = y[i] + dy[j];
                 if(dataset[nx][ny] != '#')  G[i][deg[i]++] = id[nx][ny];
                 //G[cnt编号][方向]
             }
         }
         //对于所有的位置的每一个可行的方向都记录下来
         if(n <= )  { deg[cnt] = ; G[cnt][] = cnt;    s[] = t[] = cnt++; }
         if(n <= )  { deg[cnt] = ; G[cnt][] = cnt;    s[] = t[] = cnt++; }//这里似乎是控制移动对象个数
         memset(dist, -, sizeof(dist));
         printf("%d\n", bfs());
     }
     return ;
 }

这不是我的代码，这是一个很好的代码，下面有几个方面值得借鉴学习：

1、数据结构设计十分巧妙，仅仅使用普通的数组建立的结构使得数据的查找与变换十分快捷方便

2、利用这个代码中的映射结构，提前准备好每个点可行的方向，这个可以用于平时的bfs或dfs中