HDU 1254 条件过程复杂的寻找最短路

这里一看就是找箱子到终点的最短路

一开始还傻傻的以为人的位置给的很没有意思- -，然后果然错了

没过多久想明白了错误，因为你推箱子并不是你想去哪里推就能去哪推的，首先得考虑人能否过的去，因为可能人被箱子或墙挡住都是可能的

虽然想明白了，但还是写了好久改了好久~~代码能力还是太渣了

利用dfs判定人能否走到所在的位置，bfs搜最短路

dp[i][j][4] 表示在第（i ， j）位置上可以用4个方向推箱子，所以又得乘4种状态，最后就不断bfs计算这个dp值就好了

要细心加上耐心哦~~

 /*我在这里假设箱子到了终点，我不断将它往回推，看能够推到的地方以及最短步数*/
 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <queue>
 using namespace std;
 int dir[][] = {{ , } , { , } , {- , } , { , -}};
 int m , n , dp[][][] , a[][] , vis[][][];
 int can[][]; //表示人能否到达那个位置

 struct Node{
     int x , y , pos; //pos表示人的位置，0,1,2,3表示4个方向
     Node(int x =  , int y =  , int pos = ):x(x),y(y),pos(pos){}
 };

 queue<Node> q;
 //判断箱子从x ， y按第 i 种方向推能否成立
 bool ok(int x , int y , int i)
 {
     int x1 = x+dir[i][];
     int y1 = y+dir[i][];
     int x2 = x-dir[i][];
     int y2 = y-dir[i][];
     if(x1< || x1>m || y1< || y1>n || x2< || x2>m || y2< || y2>n)
         return false;
     if(a[x1][y1] ==  || a[x2][y2] == ) return false;
     return true;
 }
 //用dfs搜索人所能走到的位置
 void dfs(int x , int y)
 {
     can[x][y] = ;
     for(int i =  ; i< ; i++){
         int tx = x+dir[i][];
         int ty = y+dir[i][];
         if(tx>= && tx<=m && ty>= && ty<=n)
             if(a[tx][ty]!= && !can[tx][ty]) dfs(tx , ty);
     }
 }
 /*判断人从x1，y1 到x2 ， y2这个位置在有箱子位于xbox ， ybox遮挡的情况下能否到达*/
 bool canTo(int x1 , int y1 , int x2 , int y2 , int xbox , int ybox)
 {
     int tmp = a[xbox][ybox];
     a[xbox][ybox] = ;//暂时将箱子所在位置变成墙

     memset(can ,  , sizeof(can));
     dfs(x1 , y1);

     a[xbox][ybox] = tmp;//还原
     if(can[x2][y2] == ) return true;
     return false;
 }

 void bfs(int sx , int sy , int pos)
 {
     dp[sx][sy][pos] = ;
     q.push(Node(sx , sy , pos));
     while(!q.empty()){
         Node u = q.front();
         q.pop();
         vis[u.x][u.y][u.pos] = ;
         for(int i =  ; i< ; i++){
             //人当前的位置
             int curx = u.x + dir[u.pos][];
             int cury = u.y + dir[u.pos][];
             //人将要走到的位置
             int nextx = u.x - dir[i][];
             int nexty = u.y - dir[i][];
             //先判定人即将到达的方向是否合理
             if(nextx <  || nextx > m || nexty <  || nexty>n) continue;
             //再判定人能否到达推箱子所在的位置
             if(!canTo(curx , cury , nextx , nexty , u.x , u.y)) continue;

             //如果箱子可以移动，那就记录移动时人所在的方向p
             int p = (i+) % ; //人是在箱子的反方向，这里可以这样用是因为dir中的方向设置的对称
             Node v = Node(u.x+dir[i][] , u.y+dir[i][] , p);

             if(ok(u.x , u.y , i)){
                // cout<<"pos: "<<v.x<<" "<<v.y<<" "<<dp[v.x][v.y]<<endl;
                 if(dp[v.x][v.y][v.pos] > dp[u.x][u.y][u.pos] + ){
                     dp[v.x][v.y][v.pos] = dp[u.x][u.y][u.pos] + ;
                     if(!vis[v.x][v.y][v.pos]){
                         vis[v.x][v.y][v.pos] = ;
                         q.push(v);
                     }
                 }
             }
         }
     }
 }

 int main()
 {
   //  freopen("a.in" , "r" , stdin);
     int T;
     scanf("%d" , &T);
     while (T--){
         scanf("%d%d" , &m , &n);
         Node tmp1 , tmp2 , tmp3; //用来记录终点的位置,和箱子的位置和人的位置
         for(int i =  ; i<=m ; i++)
             for(int j =  ; j<=n ; j++){
                 scanf("%d" , &a[i][j]);
                 if(a[i][j] == ) tmp1 = Node(i , j , );
                 if(a[i][j] == ) tmp2 = Node(i , j , );
                 if(a[i][j] == ) tmp3 = Node(i , j , );
             }

         memset(dp , 0x3f , sizeof(dp));
         memset(vis ,  , sizeof(vis));

         memset(can ,  , sizeof(can));
         a[tmp2.x][tmp2.y] = ;
         dfs(tmp3.x , tmp3.y);
         a[tmp2.x][tmp2.y] = ;
         //看最开始人能从哪个位置开始推
         for(int i =  ; i< ; i++){
             int tx = tmp2.x + dir[i][];
             int ty = tmp2.y + dir[i][];
             if(tx >=  && tx <= m && ty >=  && ty <= n)
                 if(can[tx][ty]){
                    // cout<<"haha: "<<tx<<"  " <<ty <<" "<<i<<endl;
                     bfs(tmp2.x , tmp2.y , i);
                 }
         }

         int minn = 0x3f3f3f3f;
         for(int i =  ; i< ; i++){
             minn = min(minn , dp[tmp1.x][tmp1.y][i]);
         }
         if(minn < 0x3f3f3f3f) printf("%d\n" , minn);
         else printf("-1\n");
     }
     return ;
 }