hdu 1242 Rescue

　　题目链接：hdu 1242

　　这题也是迷宫类搜索，题意说的是 'a' 表示被拯救的人，'r' 表示搜救者（注意可能有多个），'.' 表示道路（耗费一单位时间通过），'#' 表示墙壁，'x' 代表警卫（耗费两个单位时间通过），然后求出 'r' 能找到 'a' 的最短时间，找不到输出 "…………"（竟然在这里也 wa 了一发 -.-||）。很明显是广搜了，因为 'r' 可能有多个，所以我们反过来从 'a' 开始搜，每次搜到 'r' 都更新最小时间值（很重要的一个转换！）。可是这题因为通过 'x' 需要 2 单位时间导致结点间的变化不一致，所以不能用简单的队列（等下会否定这个说法），需要用优先队列，再加上 bfs 就行。

 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<queue>
 #include<algorithm>
 using namespace std;
 #define For(i,s,t)    for(int i=s; i<t; ++i)
 const int inf= 0x2fffffff;

 int n,m;
 char s[][];
 int dir[][]= {{-,},{,-},{,},{,}};

 struct node{
     int x,y,t;
     node(int x=, int y=, int t= inf): x(x),y(y),t(t) {}
     bool operator < (const node &n2) const {
         return t > n2.t;
     }
 };

 int main(){
     int si,sj;
     while(~scanf("%d%d",&n,&m)){
         getchar();
         For(i,,n+)    For(j,,m+)    s[i][j]= '#';
         for(int i=; i<=n; ++i,getchar())
             For(j,,m+)    if((s[i][j]= getchar())=='a')    si=i,    sj= j;

         int ans= ;
         priority_queue<node> q;
         q.push(node(si,sj,));
         s[si][sj]= '#';
         while(q.size()){
             node p= q.top();    q.pop();
             For(k,,){
                 int dx= p.x+dir[k][], dy= p.y+dir[k][];
                 if(s[dx][dy]!='#'){
                     q.push(node(dx,dy,(s[dx][dy]=='x'? p.t+: p.t+)));
                     if(s[dx][dy]=='r')    ans= min(ans,p.t+);
                     s[dx][dy]= '#';
                 }
             }
         }
         if(ans==)    puts("Poor ANGEL has to stay in the prison all his life.");
         else    printf("%d\n",ans);
     }
     return ;
 }

　　这一句 " if(s[dx][dy]=='r')　ans= min(ans,p.t+1); " 对 'r' 的访问和更新需要很注意位置，一定要放在 " s[dx][dy]= '#'; " 即对已访问结点做标记之前，否则 ans 的值不会变的。

　　上面是优先队列+bfs，然后这题实际上还可以用加了特技的普通队列来实现 bfs。怎么做呢，仔细观察这题每两个结点间的(边)权值实际上只有两种：1和2。2对应的就是 'x' 这个结点，只要做特殊处理就行：把它一分为二，分成两个结点 'y' 和 '.' 。大体步骤是：对每个出队的结点访问它的后继结点，当为 'x' 时，把它标记为 'y'，和其它结点一样边权值+1入队，如果为 'y'，那么就直接跳过，因为 'y' 本来就是从 'x' 转化过来的，并非从它旁边的结点扩展过来；这样的话，每次从队首出对的结点就只有两种可能：'y' 和 '#'（对于 '.' 和 'r' 入队后做的标记），如果是 'y' 的话，就把结点权值+1 再次进队（因为 'x' 本来就耗时 2），然后该结点才真正标记为 '#' 表示确实地访问完，这样的话就能用普通的队列来实现 bfs了，主要就是把那些权值不一致的结点通过拆分成多个等价的结点以转化为权值一致的图。

 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<queue>
 #include<algorithm>
 using namespace std;
 #define For(i,s,t)    for(int i=s; i<t; ++i)
 const int inf= 0x2fffffff;

 int n,m;
 char s[][];
 int dir[][]= {{-,},{,-},{,},{,}};

 struct node{
     int x,y,t;
     node(int x=, int y=, int t= inf): x(x),y(y),t(t) {}
 };

 int main(){
     int si,sj;
     while(~scanf("%d%d",&n,&m)){
         getchar();
         For(i,,n+)    For(j,,m+)    s[i][j]= '#';
         for(int i=; i<=n; ++i,getchar())
             For(j,,m+)    if((s[i][j]= getchar())=='a')    si=i,    sj= j;

         int ans= ;
         queue<node> q;
         q.push(node(si,sj,));
         s[si][sj]= '#';
         while(q.size()){
             node p= q.front();    q.pop();
             if(s[p.x][p.y]=='y'){
                 q.push(node(p.x,p.y,p.t+));
                 s[p.x][p.y]= '#';
                 continue;
             }
             For(k,,){
                 int dx= p.x+dir[k][], dy= p.y+dir[k][];
                 if(s[dx][dy]=='y')    continue;
                 if(s[dx][dy]!='#'){
                     q.push(node(dx,dy,p.t+));
                     if(s[dx][dy]=='x') {
                         s[dx][dy]= 'y';
                         continue;
                     }
                     if(s[dx][dy]=='r')    ans= min(ans,p.t+);
                     s[dx][dy]= '#';
                 }
             }
         }
         if(ans==)    puts("Poor ANGEL has to stay in the prison all his life.");
         else    printf("%d\n",ans);
     }
     return ;
 }

　　当然，这个如此巧妙的方法是从叉姐那儿听说过来的，我不过尝试着把它实现了而已，只能膜拜那些 OI 大神了 Orz ~~

　　另外，很奇怪的是，这题居然也能用 dfs 来做：

 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<algorithm>
 using namespace std;
 #define For(i,s,t)  for(int i=s; i<t; ++i)
 const int maxn= +;

 char ch[maxn][maxn];
 int dir[][]= {{-,,,},{,-,,}};
 int Min, num;

 void dfs(int i, int j, int len)
 {
     ++num;
     if(ch[i][j]=='#')    return ;
     if(ch[i][j]=='x')    ++len;
     if(len > Min)    return ;
     if(ch[i][j]=='r'){
         Min= min(Min,len);
         return ;
     }
     char c= ch[i][j];
     ch[i][j]= '#';
     For(k,,) {
         int dx= i+dir[][k], dy= j+dir[][k];
         dfs(dx,dy,len+);
     }
     ch[i][j]= c;
 }

 int main()
 {
     int n,m,si,sj;
     while(~scanf("%d%d",&n,&m))
     {
         getchar();
         memset(ch,'#',sizeof(ch));
         for(int i=; i<=n; ++i,getchar())
             For(j,,m+)    if((ch[i][j]= getchar())=='a')    si= i,    sj=j;

         Min= ;
         dfs(si,sj,);
         if(Min==)    puts("Poor ANGEL has to stay in the prison all his life.");
         else    printf("%d\n",Min);
     }
     return ;
 }

　　对于这样的题来说 dfs 应该很容易超时才对，可是实际上和 bfs 相差无几，只能再一次吐槽下杭电数据的弱了，anyway，我还是会继续被 HDOJ 虐……