HDU5040- Instrusive(BFS+记忆化搜索)
题目链接
题意：给定一张图，Matt要从M移动到T取偷东西，N，W，S，E表示这些位置有监控器，字母表示这些监控器的初始方向，并且每一秒顺时针旋转90度。现在Matt每移动一格需要花一秒，但是如果当前他所在的位置或者他要去的位置被监控器监视，那么如果他要移动，就必须躲在箱子里移动，时间需要花费3秒。或者也可以选择不移动，躲在箱子里1秒，问说Matt最少花费多少时间移动到T。
思路：借鉴的是小伙伴的想法，先预处理整张图，用二进制表示在一个周期(4S)内每个格子是否会被监控器监控到，之后状态要多开一维，表示4S一个周期，然后进行状态转移。
代码：
#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
using namespace std;
const int MAXN = 505;
const int INF = 0x3f3f3f3f;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
struct node{
node(int xx, int yy, int tt) {
x = xx;
y = yy;
t = tt;
}
int x, y, t;
};
char map[MAXN][MAXN];
int g[MAXN][MAXN], d[MAXN][MAXN][5];
int n, sx, sy, ex, ey;
int change(char c) {
if (c == 'N') return 0;
if (c == 'E') return 3;
if (c == 'S') return 2;
if (c == 'W') return 1;
return -1;
}
int bfs(int x, int y, int t) {
queue<node> q;
node s(x, y, 0);
q.push(s);
memset(d, INF, sizeof(d));
d[s.x][s.y][s.t] = 0;
int ans = INF;
while (!q.empty()) {
node u = q.front();
q.pop();
node v = u;
if (v.x == ex && v.y == ey)
ans = min(ans, d[v.x][v.y][v.t]);
v.t = (v.t + 1) % 4;
if (d[v.x][v.y][v.t] > d[u.x][u.y][u.t] + 1) {
d[v.x][v.y][v.t] = d[u.x][u.y][u.t] + 1;
q.push(v);
}
for (int i = 0; i < 4; i++) {
node v = u;
v.x = u.x + dx[i];
v.y = u.y + dy[i];
int step = 0;
if (v.x < 0 || v.x >= n || v.y < 0 || v.y >= n || g[v.x][v.y] == -1) continue;
if ((g[u.x][u.y] & (1<<u.t)) || (g[v.x][v.y] & (1<<u.t))) {
v.t = (v.t + 3) % 4;
step = 3;
}
else {
v.t = (v.t + 1) % 4;
step = 1;
}
if (d[v.x][v.y][v.t] > d[u.x][u.y][u.t] + step) {
d[v.x][v.y][v.t] = d[u.x][u.y][u.t] + step;
q.push(v);
}
}
}
return ans;
}
int main() {
int cas, t = 1;
scanf("%d", &cas);
while (cas--) {
scanf("%d", &n);
memset(g, 0, sizeof(g));
memset(map, 0, sizeof(map));
for (int i = 0; i < n; i++) {
scanf("%s", map[i]);
for (int j = 0; j < n; j++) {
if (map[i][j] == 'M') {
sx = i;
sy = j;
}
else if (map[i][j] == 'T') {
ex = i;
ey = j;
}
else if (map[i][j] == '#')
g[i][j] = -1;
else if (change(map[i][j]) != -1) {
g[i][j] = 15;
for (int k = 0; k < 4; k++) {
int tx = i + dx[k];
int ty = j + dy[k];
if (tx < 0 || tx >= n || ty < 0 || ty >= n || map[tx][ty] == '#') continue;
g[tx][ty] |= (1<<((change(map[i][j]) + k) % 4));
}
}
}
}
printf("Case #%d: ", t++);
int ans = bfs(sx, sy, 0);
if (ans >= INF)
printf("-1\n");
else
printf("%d\n", ans);
}
return 0;
}
用记忆化搜索差点就超时了，所以用BFS+优先队列会更好，思想其实是差不多的。
#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
using namespace std;
const int N = 505;
const int dx[] = {-1, 0, 1, 0, 0};
const int dy[] = {0, -1, 0, 1, 0};
int vis[N][N][5], b[N][N][5];
char g[N][N];
int n, sx, sy, ex, ey;
struct node{
node(int xx, int yy, int dd) {
x = xx;
y = yy;
d = dd;
}
int x, y, d;
friend bool operator < (node a, node b) {
return a.d > b.d;
}
};
int bfs(int x,int y) {
priority_queue <node> q ;
node s(x, y, 0);
q.push(s) ;
memset(vis,0,sizeof(vis)) ;
vis[x][y][0] = 1 ;
while(!q.empty()) {
node u = q.top() ;
q.pop();
if(u.x == ex && u.y == ey)
return u.d ;
for(int i = 0 ;i < 5 ;i++) {
int tx = u.x + dx[i] ;
int ty = u.y + dy[i] ;
if(tx < 0 || tx >= n || ty < 0 || ty >= n || g[tx][ty] == '#')continue ;
node p = u;
if(b[tx][ty][u.d%4] || b[u.x][u.y][u.d%4]) {
if(tx == u.x && ty == u.y && !vis[tx][ty][(u.d+1)%4]) {
p.d++ ;
vis[tx][ty][p.d%4]=1 ;
q.push(p) ;
}
else if(!vis[tx][ty][(u.d+3)%4]) {
p.x=tx;
p.y=ty ;
p.d += 3 ;
vis[tx][ty][p.d%4]=1 ;
q.push(p) ;
}
}
else if(!vis[tx][ty][(u.d+1)%4]) {
p.x=tx;
p.y=ty;
p.d++ ;
vis[tx][ty][p.d%4]=1 ;
q.push(p) ;
}
}
}
return -1 ;
}
int main() {
int cas, t = 1;
scanf("%d", &cas);
while (cas--) {
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%s", g[i]);
memset(b, 0, sizeof(b));
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
if (g[i][j] == 'M') {
sx = i;
sy = j;
}
else if (g[i][j] == 'T') {
ex = i;
ey = j;
}
else if (g[i][j] == 'N') {
b[i][j][0] = b[i][j][1] = b[i][j][2] = b[i][j][3] = 1;
if (i - 1 >= 0) b[i - 1][j][0] = 1;
if (j + 1 < n) b[i][j + 1][1] = 1;
if (i + 1 < n) b[i + 1][j][2] = 1;
if (j - 1 >= 0) b[i][j - 1][3] = 1;
}
else if (g[i][j] == 'W') {
b[i][j][0] = b[i][j][1] = b[i][j][2] = b[i][j][3] = 1;
if (j - 1 >= 0) b[i][j - 1][0] = 1;
if (i - 1 >= 0) b[i - 1][j][1] = 1;
if (j + 1 < n) b[i][j + 1][2] = 1;
if (i + 1 < n) b[i + 1][j][3] = 1;
}
else if (g[i][j] == 'S') {
b[i][j][0] = b[i][j][1] = b[i][j][2] = b[i][j][3] = 1;
if (i + 1 < n) b[i + 1][j][0] = 1;
if (j - 1 >= 0) b[i][j - 1][1] = 1;
if (i - 1 >= 0) b[i - 1][j][2] = 1;
if (j + 1 < n) b[i][j + 1][3] = 1;
}
else if (g[i][j] == 'E') {
b[i][j][0] = b[i][j][1] = b[i][j][2] = b[i][j][3] = 1;
if (j + 1 < n) b[i][j + 1][0] = 1;
if (i + 1 < n) b[i + 1][j][1] = 1;
if (j - 1 >= 0) b[i][j - 1][2] = 1;
if (i - 1 >= 0) b[i - 1][j][3] = 1;
}
}
printf("Case #%d: %d\n", t++, bfs(sx, sy));
}
return 0;
}