La 4128 Steam Roller 状态图上的Dijkstra

题目大意：
给定一个R行C列的网格图和图上的边权（0表示两点之间无法连通）, 并已知起点，终点，每次转弯或者启动、停止时需要耗费双倍时间(从上一条边到这一条边的转向和从这条边到下一条边的转向最多计算一次）， 求到终点的最短路径。
分析：
我们可以用一个大的状态图来存储整个复杂的图，利用（r, c, dir, doubled)这个状态来表示从上一个点沿着dir的方向到达当前点（r, c）的这条边的状态，doubled表示这条边有没有加倍过，用来避免多次加倍，这样整个图就变成了一个更大的状态转移图，状态转移图的边权可以通过预处理的方式出来。（p.s.注意在更新过程中判断路径是否可行）
代码：

#include<bits/stdc++.h>
using namespace std;
const int maxr = 100 + 10;
const int maxn = 100 * 100 * 8 + 10;
const int INF = 0x3f3f3f3f;
const int Up = 0, Left = 1, Down = 2, Right = 3;

const int inv[] = {2, 3, 0, 1};
const int dr[] = {-1, 0, 1, 0};
const int dc[] = {0, -1, 0, 1};

int grid[maxr][maxr][4];
int n, id[maxr][maxr][4][2];
int R, C, r1, c1, r2, c2, Case;

int read() {
    int x = 0, f = 1;
    char ch = getchar();
    while(ch < '0' || ch > '9') { if(ch == '-') f = -1; ch = getchar(); }
    while(ch >='0' && ch <='9') { x = x * 10 + ch - 48; ch = getchar(); }
    return x * f;
}
struct Edge {
    int from, to, dist;
};
struct Heapnode {
    int d, u;
    bool operator < (const Heapnode& rhs) const {
        return d > rhs.d;
    }
};
struct Dijkstra {
    int n, m;
    vector<int> G[maxn];
    vector<Edge> edges;
    bool done[maxn];
    int dis[maxn], pre[maxn];

    void init(int n) {
        this -> n = n;
        for(int i=0; i<n; i++) G[i].clear();
        edges.clear();
    }
    void add(int from, int to, int dist) {
        edges.push_back((Edge){from, to, dist});
        m = edges.size();
        G[from].push_back(m-1);
    }
    void dijkstra(int s) {
        priority_queue<Heapnode> q;
        memset(done, false, sizeof(done));
        for(int i=0; i<n; i++) dis[i] = INF; dis[s] = 0;

        q.push((Heapnode){0, s});
        while(!q.empty()) {
            Heapnode x = q.top(); q.pop();
            int u = x.u; if(done[u]) continue; done[u] = true;

            for(int i=0; i<(int)G[u].size(); i++) {
                Edge e = edges[G[u][i]];
                if(!done[e.to] && dis[e.to] > dis[u] + e.dist) {
                    dis[e.to] = dis[u] + e.dist;
                    pre[e.to] = G[u][i];
                    q.push((Heapnode){dis[e.to], e.to});
                }
            }
        }
    }
}Dij; 
inline int ID(int r, int c, int dir, int doubled) {
    int &x = id[r][c][dir][doubled];
    if(x == 0) x = ++n;
    return x;
}
inline bool cango(int r, int c, int dir) {
    if(r < 0 || r >= R || c < 0 || c >= C) return false;
    return grid[r][c][dir] > 0;
}

int main() {
#ifndef ONLINE_JUDGE 
    freopen("data.txt", "r", stdin);
    freopen("ans.txt", "w", stdout);
#endif
    while(scanf("%d%d%d%d%d%d", &R, &C, &r1, &c1, &r2, &c2) == 6 && R+C) {
        r1--, c1--, r2--, c2--;
        for(int r=0; r<R; r++) {
            for(int c=0; c<C-1; c++) 
                grid[r][c][Right] = grid[r][c+1][Left] = read();
            if(r != R-1) for(int c=0; c<C; c++) 
                grid[r][c][Down] = grid[r+1][c][Up] = read();
        }
        Dij.init(R*C*8 + 1);

        n = 0;
        memset(id, 0, sizeof(id));

        for(int dir=0; dir<4; dir++) if(cango(r1, c1, dir)) 
            Dij.add(0, ID(r1 + dr[dir], c1 + dc[dir], dir, 1), grid[r1][c1][dir] * 2);

        for(int r=0; r<R; r++) 
            for(int c=0; c<C; c++) 
                for(int dir=0; dir<4; dir++) if(cango(r, c, inv[dir]))
                    for(int newdir=0; newdir<4; newdir++) if(cango(r, c, newdir))
                        for(int doubled=0; doubled<2; doubled++) {
                            int newr = r + dr[newdir];
                            int newc = c + dc[newdir];
                            int v = grid[r][c][newdir], newdoubled = 0;
                            if(dir != newdir) {
                                if(!doubled) v += grid[r][c][inv[dir]];
                                newdoubled = 1; v += grid[r][c][newdir];
                            }
                            Dij.add(ID(r, c, dir, doubled), ID(newr, newc, newdir, newdoubled), v);
                        }

        Dij.dijkstra(0);

        int ans = INF;
        for(int dir = 0; dir < 4; dir++) if(cango(r2, c2, inv[dir])) 
            for(int doubled = 0; doubled < 2; doubled++) {
                int v = Dij.dis[ID(r2, c2, dir, doubled)];
                if(!doubled) v += grid[r2][c2][inv[dir]];
                ans = min(ans, v);
            }
        printf("Case %d: ", ++Case);
        if(ans == INF) printf("Impossible\n"); else printf("%d\n", ans); 
    }
    return 0;
}