RQNOJ 342 最不听话的机器人：网格dp

题目链接：https://www.rqnoj.cn/problem/342

题意：

　　DD 有一个不太听话的机器人，这个机器人总是会有自己的想法，而不会完全遵守 DD 给它的指令。

　　现在 DD 在试图命令机器人走迷宫。迷宫是一个 N*N 个格子组成的区域，格子自左上角到右下角从 (1,1) 到 (N,N) 编号。第 i 行、第 j 列的格子编号为 (i,j)。迷宫中的某些区域是障碍物，机器人不能移动到那里。

　　DD 给了机器人 M 条指令，指令的类型包括“前进一步”“后退一步”“左转九十度”“右转九十度”。但问题是机器人并不能完全遵守这些指令，因为如果机器人完全遵守这些指令，它可能会走到障碍物的格子里或者走到迷宫外面去，那样就会有危险。机器人希望从这个指令序列里面去掉一些，然后执行剩下的指令时，可以保证整个过程中都不会有危险。

　　机器人虽然不太听话，但它并不想惹恼了 DD，否则 DD 可能会把它拆掉的。所以机器人希望去掉的指令尽量少。

　　迷宫的大小是 N*N，指令共有 M 条，机器人初始时的位置是 (X0,Y0)。机器人初始时面朝的方向是上方。

　　那么，机器人最少需要去掉多少条指令才能保证不会有危险呢？

题解：

　　表示状态：

　　　　dp[i][x][y][d] = min num of deleted orders

　　　　i：考虑到第i条指令

　　　　x,y：当前位置

　　　　d：当前方向

　　找出答案：

　　　　min legal dp[m][x][y][d]

　　如何转移：

　　　　now: dp[i][x][y][d]

　　　　dp[i+1][x][y][d] = min dp[i][x][y][d] + 1　（不执行）

　　　　dp[i+1][nx][ny][nd] = min dp[i][x][y][d]　（执行）

　　　　nx,ny,nd为执行第i条指令后的位置和方向。

　　边界条件：

　　　　dp[0][x0][y0][UP] = 0

　　　　ohters = INF

　　　　（UP为方向向上的编号）

　　注：空间限制，要把第一维[MAX_M]变为[2]。

　　小技巧：

　　　　如果压维的时候前后数据间有影响，则可以开一个vis数组。

　　　　更新dp[i&1][x][y][d]时，将vis[i&1][x][y][d] = i，意为当前dp的位置是在i的时候更新的。

　　　　每次用到dp[i&1][x][y][d]时，判断一下相应的vis。

　　　　如果vis[i&1][x][y][d] = i，则返回dp值，否则返回初始值INF（dp[i][x][y][d]这个状态还没被更新过）。

AC Code:

 // state expression:
 // dp[i][x][y][d] = min num of deleted orders
 // i: considering ith order
 // x,y: present pos
 // d: present direction
 //
 // find the answer:
 // min legal dp[m][x][y][d]
 //
 // transferring:
 // now: dp[i][x][y][d]
 // dp[i+1][x][y][d] = min dp[i][x][y][d] + 1
 // dp[i+1][nx][ny][nd] = min dp[i][x][y][d]
 //
 // bound:
 // dp[0][x0][y0][UP] = 0
 // ohters = INF
 #include <iostream>
 #include <stdio.h>
 #include <string.h>
 #define MAX_N 105
 #define MAX_M 1005
 #define MAX_D 5
 #define INF 10000000

 using namespace std;

 const int dx[]={-,,,};
 const int dy[]={,,,-};

 int n,m,x0,y0;
 int ans;
 int c[MAX_M];
 int dp[][MAX_N][MAX_N][MAX_D];
 int vis[][MAX_N][MAX_N][MAX_M];
 char a[MAX_N][MAX_N];

 void read()
 {
     cin>>n>>m>>x0>>y0;
     for(int i=;i<=n;i++)
     {
         for(int j=;j<=n;j++)
         {
             cin>>a[i][j];
         }
     }
     string s;
     for(int i=;i<m;i++)
     {
         cin>>s;
         if(s=="FORWARD") c[i]=;
         if(s=="BACK") c[i]=;
         if(s=="LEFT") c[i]=;
         if(s=="RIGHT") c[i]=;
     }
 }

 void cal_pos(int &x,int &y,int &d,int c)
 {
     if(c==)
     {
         x+=dx[d];
         y+=dy[d];
         return;
     }
     if(c==)
     {
         x-=dx[d];
         y-=dy[d];
         return;
     }
     if(c==)
     {
         d=(d+)%;
         return;
     }
     if(c==)
     {
         d=(d+)%;
         return;
     }
 }

 inline bool is_legal(int x,int y)
 {
     return x> && x<=n && y> && y<=n && a[x][y]!='*';
 }

 void solve()
 {
     memset(dp,0x3f,sizeof(dp));
     memset(vis,-,sizeof(vis));
     dp[][x0][y0][]=;
     vis[][x0][y0][]=;
     for(int i=;i<m;i++)
     {
         for(int x=;x<=n;x++)
         {
             for(int y=;y<=n;y++)
             {
                 if(a[x][y]!='*')
                 {
                     for(int d=;d<;d++)
                     {
                         if(vis[i&][x][y][d]==i)
                         {
                             int temp;
                             if(vis[(i+)&][x][y][d]!=i+) temp=INF;
                             else temp=dp[(i+)&][x][y][d];
                             dp[(i+)&][x][y][d]=min(temp,dp[i&][x][y][d]+);
                             vis[(i+)&][x][y][d]=i+;
                             int nx=x,ny=y,nd=d;
                             cal_pos(nx,ny,nd,c[i]);
                             if(is_legal(nx,ny))
                             {
                                 if(vis[(i+)&][nx][ny][nd]!=i+) temp=INF;
                                 else temp=dp[(i+)&][nx][ny][nd];
                                 dp[(i+)&][nx][ny][nd]=min(temp,dp[i&][x][y][d]);
                                 vis[(i+)&][nx][ny][nd]=i+;
                             }
                         }
                     }
                 }
             }
         }
     }
     ans=m;
     for(int x=;x<=n;x++)
     {
         for(int y=;y<=n;y++)
         {
             if(a[x][y]!='*')
             {
                 for(int d=;d<;d++)
                 {
                     if(vis[m&][x][y][d]==m)
                     {
                         ans=min(ans,dp[m&][x][y][d]);
                     }
                 }
             }
         }
     }
 }

 void print()
 {
     cout<<ans<<endl;
 }

 int main()
 {
     read();
     solve();
     print();
 }