Uva 1078 Steam Roller（多状态最短路）

题意：有一个n条竖线m条横线组成的网络，你的任务是开着一辆蒸汽压路机，用最短的时间从一个点到另一个点，其中一些线段上的权值表示压路机全速前进所用的时间，0表示不能通过，由于蒸汽机的惯性较大所以在转弯前和转弯后那条边所走的实际速度都是全速前进速度的两倍。开始后和结束前的边也是两倍。时间加倍的规则是不会叠加的。最后给你两个顶点求最短路。

思路：设d[i][j][k][l] : 沿着第k(1 <= k <= 4)个方向到达(i, j)时下一步是否转弯(l 的取值 0/1)的最短路，然后dijkstra, 求出下一个点的转态d[I][J][K][L],

显然l == 0（不转弯的时候），只能取k == K的转态，选择不转弯的最短路

l == 1（转弯），只能取k != K，选择转弯的最短路

若L = 0，d[I][J][K][0] = d[i][j][k][l] + cost; 下一次还不转弯，注意如果l = 1多加一个cost，因为是刚转弯后，无论是直行还是转弯都是 2倍的cost

若L = 1，毫无疑问 d[I][J][K][1] = d[i][j][k][l] + 2 * cost;

还一点要注意的就是起点终点一样的时候，答案不是0，机器有初速度，这里WA了n次......

#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<cstdlib>
#include<algorithm>
const int maxn = 110;
const int INF = 1e9;
using namespace std;

struct P {
    int x, y, cost, dir, turn;
    P() {}
    P(int xx, int yy, int c, int d, int t) {
        x = xx;    y = yy;
        cost = c;  dir = d;
        turn = t;
    }
};
int R, C, r1, c1, r2, c2;
int d[maxn][maxn][5][2];
int maze[2 * maxn][2 * maxn];
int dx[] = {0, 0, 1, 0, -1};
int dy[] = {0, 1, 0, -1, 0};
vector<P> G[maxn * maxn];

bool operator < (P a, P b) {
    return a.cost > b.cost;
}

int point(int x, int y) {
    return x * C + y;
}

int limit(int x, int y) {
    if(x < 0 || x >= R || y < 0 || y >= C) return 0;
    return 1;
}

void init() {
    r1--; c1--;
    r2--; c2--;
    memset(maze, 0, sizeof(maze));
    for(int i = 0; i < maxn * maxn; i++)
        G[i].clear();
    for(int i = 0; i < maxn; i++) {
        for(int j = 0; j < maxn; j++) {
            for(int k = 0; k < 5; k++) {
                for(int l = 0; l < 2; l++) {
                    if(i != r1 || j != c1) d[i][j][k][l] = INF;
                    else d[i][j][k][l] = 0;
                }
            }
        }
    }
}

int dijkstra() {
    priority_queue<P> q;
    q.push(P(r1, c1, 0, 0, 1));
    while(!q.empty()) {
        P st = q.top(); q.pop();
        if(st.x == r2 && st.y == c2 && st.turn && st.cost) return st.cost;
        int di = st.dir, t = st.turn;
        if(d[st.x][st.y][di][t] < st.cost) continue;
        int u = point(st.x, st.y);
        for(int i = 0; i < G[u].size(); i++) {
            P p = G[u][i];
            int dis = p.dir;
            if(t == 0 && dis != di) continue;
            if(t == 1 && dis == di) continue;
            int res1 = d[st.x][st.y][st.dir][t] + p.cost;
            int res2 = d[st.x][st.y][st.dir][t] + 2 * p.cost;
            if(t) res1 += p.cost;
            if(d[p.x][p.y][dis][0] > res1 || !d[p.x][p.y][dis][0]) {
                d[p.x][p.y][dis][0] = res1;
                q.push(P(p.x, p.y, res1, dis, 0));
            }
            if(d[p.x][p.y][dis][1] > res2 || !d[p.x][p.y][dis][1]) {
                d[p.x][p.y][dis][1] = res2;
                q.push(P(p.x, p.y, res2, dis, 1));
            }
        }
    }
    return INF;
}

int main() {
    int t = 1;
    //freopen("e:\\in.txt", "r", stdin);
    //freopen("e:\\out2.txt","w",stdout);
    while(scanf("%d%d%d%d%d%d", &R, &C, &r1, &c1, &r2, &c2) != EOF) {
        if(!R || !C || !r1 || !c1 || !r2 || !c2) break;
        init();
        for(int i = 0; i < 2 * R - 1; i++) {
            for(int j = 0; j < 2 * C - 1; j++) {
                if((i + j) & 1) scanf("%d", &maze[i][j]);
            }
        }
        for(int i = 0; i < R; i++) {
            for(int j = 0; j < C; j++) {
                for(int k = 1; k < 5; k++) {
                    int x = i + dx[k], y = j + dy[k];
                    if(!limit(x, y)) continue;
                    int fx, fy;
                    if(i == x) { fx = i * 2; fy = j + y; }
                    if(j == y) { fy = j * 2; fx = i + x; }
                    if(!maze[fx][fy]) continue;
                    int A = point(i, j);
                    G[A].push_back(P(x, y, maze[fx][fy], k, 0));
                }
            }
        }
        int ans = dijkstra();
        printf("Case %d: ", t++);
        if(ans == INF) printf("Impossible\n");
        else printf("%d\n", ans);
    }
    return 0;
}