UVa Problem 10047 The Monocycle（独轮车）

// The Monocycle（独轮车）
// PC/UVa IDs: 111202/10047, Popularity: C, Success rate: average Level: 3
// Verdict: Accepted
// Submission Date: 2011-11-01
// UVa Run Time: 0.076s
//
// 版权所有（C）2011，邱秋。metaphysis # yeah dot net
//
// [解题方法]
// 本题可以归结为图的遍历，动态规划问题。题目所要求的是到达终点 T 时，轮子绿色部分中心着地时的最短
// 时间，如果能通过遍历到达终点 T，则肯定存在一个最短时间，否则说明起点 S 和终点 T 之间无通路，目
// 标不可达。若遍历能到达终点 T，不一定刚好是绿色部分中心着地，即走的步数刚好是 5 的倍数，那么就
// 需要从这些路径中选一条达到终点 T 时，中心着地部分为绿色且时间最短的一条，这个可以通过动态规划
// 来解决。使用 minTime[i][j][c][d] 表示在位置（i，j）颜色为 c，方向为 d 时的最小到达时间，
// 在遍历中更新该时间，大于等于该时间的同等状态不再继续扩展进行遍历，最后取终点 T，中心着地颜色为
// 绿色时的到达时间最小值，若最小值还是预设的 MAXINT，则表示目标不可达。

#include <iostream>
#include <queue>
#include <set>

using namespace std;

#define MAXN 25			// 地面大小最大值。
#define MAXCOLORS 5		// 颜色数目。
#define MAXD 4			// 方向数目。
#define MAXINT (1 << 20)	// 预设的最大时间。为该值则表示不可达。

// 面朝方向。
#define NORTH 0
#define SOUTH 1
#define WEST 2
#define EAST 3

// 中心着地部分颜色。
#define GREEN 0
#define BLACK 1
#define RED 2
#define BLUE 3
#define WHITE 4

// 独轮车手状态。
struct state
{
int x, y;	// 所处位置。
int time;	// 已用时间。
int direction;	// 面朝方向。
int color;	// 中心着地部分颜色。
};

// 到达位置（i，j）时，中心着地部分颜色为 c，方向为 d 时的最小时间。
int minTime[MAXN][MAXN][MAXCOLORS][MAXD];
// 表示地面的字符数组。
char matrix[MAXN][MAXN];
// 测试例数，表示地面矩阵的行数，列数。
int cases = 1, line, row;
// 从当前方向 i 到转到方向 j 所需时间，如 delay[NORTH][SOUTH] 表示从朝北方向转到朝南方向，所
// 需时间为 2 秒，因为要在原地转两次 90 度。
int delay[MAXD][MAXD] = {
{ 0, 2, 1, 1 }, { 2, 0, 1, 1 }, { 1, 1, 0, 2 }, { 1, 1, 2, 0 } };
int offset[MAXD][2] = { { -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 } };
// 表示起点和终点的位置。
pair < int, int > sIndex, tIndex;

void dynamic_programming(void)
{
// 置初始值。
for (int i = 0; i < line; i++)
for (int j = 0; j < row; j++)
for (int c = GREEN; c <= WHITE; c++)
for (int d = NORTH; d <= EAST; d++)
minTime[i][j][c][d] = MAXINT;

// 压入初始状态。
queue < state > states;
states.push((state){sIndex.first, sIndex.second, 0, NORTH, GREEN});

// 宽度优先遍历。
while (!states.empty())
{
state s = states.front();
states.pop();

// 比较状态，更新相同状态到达时间的最小值。
if (s.time >= minTime[s.x][s.y][s.color][s.direction])
continue;
else
minTime[s.x][s.y][s.color][s.direction] = s.time;

// 原地转方向。
for (int d = NORTH; d <= EAST; d++)
{
if (d == s.direction)
continue;

states.push((state){s.x, s.y, s.time +
delay[s.direction][d], d, s.color});
}

// 若前后左右无障碍且在地面范围内，则前进。
for (int d = NORTH; d <= EAST; d++)
{
int x = s.x + offset[d][0];
int y = s.y + offset[d][1];

if (x < 0 || x >= line || y < 0 || y >= row)
continue;
if (matrix[x][y] == '#')
continue;

states.push((state){x, y, s.time + delay[s.direction][d] + 1,
d, (s.color + 1) % MAXCOLORS});
}
}

// 取到达终点 T 时的最小到达时间。
int minimum = MAXINT;
for (int i = NORTH; i <= EAST; i++)
minimum = min(minimum, minTime[tIndex.first][tIndex.second][GREEN][i]);

// 输出空行。
if (cases >= 2)
cout << endl;

// 输出结果。
cout << "Case #" << cases++ << endl;
if (minimum < MAXINT)
cout << "minimum time = " << minimum << " sec" << endl;
else
cout << "destination not reachable" << endl;
}

int main(int ac, char *av[])
{
while (cin >> line >> row, line || row)
{
for (int i = 0; i < line; i++)
for (int j = 0; j < row; j++)
{
cin >> matrix[i][j];
if (matrix[i][j] == 'S')
sIndex = make_pair(i, j);
if (matrix[i][j] == 'T')
tIndex = make_pair(i, j);
}

dynamic_programming();
}

return 0;
}