POJ 2688 Cleaning Robot（BFS + A* + 状态压缩DP）
题意：
给你一个N * M（1 ≤ N, M ≤ 20）的地图，'.'表示空位，'*'表示垃圾，'o'表示机器人的初始位置，'x'表示墙。请你计算机器人清理完所有的垃圾至少要走多少步。
机器人一旦走到垃圾上，垃圾就被清掉了。输入数据保证垃圾不多于10个。
思路：
1. 先 BFS 求出任意两个污点间所需要的最小步数。题目保证了污点数不超过 10 个，这时候可以应用经典的 TSP 模型，用状态压缩 dp 解决之;
2. dp[u][s] 代表以 u 结束的状态 s 需要经过的最小步数。 s 中的位代表已经选择了的污点，初始状态 dp[0][0] = 0, 其他赋值 INFS，求解 dp[i][ends] 最小值。
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
const int INFS = 0x3fffffff;
const int dir[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
char grid[25][25];
int col, row, dis[15][15];
bool vis[25][25];
struct Dirty {
int x, y;
} dirty[20] ;
struct ST {
int x, y, step, f;
ST(int _x, int _y, int _step, int _f) : x(_x), y(_y), step(_step), f(_f) {}
bool operator < (const ST& other) const {
return f > other.f;
}
};
bool judge(int x, int y) {
if (0 < x && x <= row && 0 < y && y <= col && grid[x][y] != 'x') {
return true;
}
return false;
}
int getdiff(const Dirty& a, const Dirty& b) {
return abs(a.x - b.x) + abs(a.y - b.y);
}
int bfs(const Dirty& src, const Dirty& dst) {
priority_queue<ST> Q;
Q.push(ST(src.x, src.y, 0, getdiff(src, dst)));
memset(vis, false, sizeof(vis));
vis[src.x][src.y] = true;
while (!Q.empty()) {
ST u = Q.top();
Q.pop();
if (u.x == dst.x && u.y == dst.y)
return u.step;
for (int i = 0; i < 4; i++) {
Dirty v;
v.x = u.x + dir[i][0];
v.y = u.y + dir[i][1];
if (judge(v.x, v.y) && !vis[v.x][v.y]) {
vis[v.x][v.y] = true;
int f = u.step + 1 + getdiff(v, dst);
Q.push(ST(v.x, v.y, u.step + 1, f));
}
}
}
return -1;
}
int dp[12][1<<12];
int dirtycnt;
inline int getflag(int r) {
return 1 << r;
}
int dfs(int state, int u) {
if (dp[u][state] != INFS)
return dp[u][state];
int s = state ^ getflag(u - 1);
if (s == 0)
return dis[0][u];
for (int i = 1; i <= dirtycnt; i++) {
if (s & getflag(i-1)) {
dp[u][state] = min(dp[u][state], dfs(s, i) + dis[i][u]);
}
}
return dp[u][state];
}
int main() {
while (scanf("%d%d", &col, &row) && col && row) {
memset(dirty, 0, sizeof(dirty));
dirtycnt = 0;
for (int i = 1; i <= row; i++) {
scanf("%s", &grid[i][1]);
for (int j = 1; j <= col; j++) {
if (grid[i][j] == '*') {
dirtycnt += 1;
dirty[dirtycnt].x = i;
dirty[dirtycnt].y = j;
} else if (grid[i][j] == 'o') {
dirty[0].x = i; dirty[0].y = j;
}
}
}
bool flag = false;
for (int i = 0; i <= dirtycnt; i++) {
for (int j = i; j <= dirtycnt; j++) {
if (i == j) {
dis[i][j] = 0;
} else {
dis[j][i] = dis[i][j] = bfs(dirty[i], dirty[j]);
if (dis[i][j] == -1) {
flag = true; break;
}
}
}
}
if (flag) {
printf("-1\n"); continue;
}
int ends = getflag(dirtycnt) - 1;
for (int i = 0; i <= dirtycnt; i++) {
for (int j = 0; j <= ends; j++)
dp[i][j] = INFS;
}
dp[0][0] = 0;
int ans = INFS;
for (int i = 1; i <= dirtycnt; i++)
ans = min(ans, dfs(ends, i));
printf("%d\n", ans);
}
return 0;
}