uva 1078(LA 4128Dijkstra+建图)

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

思路：这道题难点就是建图了，显示自己思考想了好多种方法但是最后在实现的时候都发现思路比较乱，写到最后还是放弃了。最后选用了liurujia书上的第二种方法，主要是比较简单又好理解。其中的一个4号定点表示静止点，0-3分别表示四个方向。四个方向的顶点只有和自己同一方向的节点才会有边联系，若是想要转向则先改变成静止状态，然后再变成相应的方向。这样的话从启动到静止，再到启动正好前后两条边都增加了两遍。另外书上说的一个点走一步后就静止了会出现和题意不符合的情况，这种情况需要单独建边。这样为了方便最短路的算法执行，我们再加一个0号定点指向出发点。这样只要执行一次Dijkstra算法就行了。

另外，从liurujia的树上有学到了一种很好的借点标号的方式，他是开了一个数组，标记每个点的映射值，若是没有标记为0。（所以是从1开始的）原来我都是根据一个顶点拆分成多少个点来标记，这样往往还要通过公式来换算所以不太方便。这个方法就显得非常方便而且不容易出错又灵活，在建完图之后定点的个数就自动确定了，也不用自己计算。

代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
#include <cmath>
#define MP(a, b) make_pair(a, b)
#define PB(a) push_back(a)

using namespace std;

typedef pair<int, int> pii;
typedef long long ll;

const int INF = 0x3f3f3f3f;
const double eps = 1E-6;
const int LEN = 100010;
const int MLEN = 110;
const int UP = 0, LEFT = 1, DOWN = 2, RIGHT = 3;
const int xx[] = {-1, 0, 1, 0};
const int yy[] = { 0,-1, 0, 1};
int dis[LEN], n, m, sx, sy, ex, ey, N;
int edg[MLEN][MLEN][4], id[MLEN][MLEN][5];
vector<pii> Map[LEN];

//change the id 这个函数第一次见感觉自动编号还是很好，以前都是通过一套公式换算比较烦。
inline int ch(int rp, int cp, int dip){
    int &x = id[rp][cp][dip];
    if(x==0)return x = ++N;
    else return x;
}
inline bool je(int x, int y, int dip)
{
    if(x<1 || x>n || y<1 || y>m) return false;
    else return edg[x][y][dip]>0;
}
inline int readi(){int x; scanf("%d", &x);return x;}

void Dijkstra(int s)
{
    priority_queue<pii, vector<pii>, greater<pii> > q;
    int vis[LEN] = {0};
    memset(dis , 0x3f, sizeof dis);
    dis[s] = 0;
    q.push(MP(dis[s], s));
    while(!q.empty())
    {
        pii nvex = q.top(); q.pop();
        int nv = nvex.second;
        if(vis[nv])continue;
        vis[nv] = 1;
        for(int i=0; i<Map[nv].size(); i++){
            int x = Map[nv][i].first, y = Map[nv][i].second;
            if(dis[x]>dis[nv]+y){
                dis[x] = dis[nv]+y;
                q.push(MP(dis[x], x));
            }
        }
    }

}

void readmap()
{
    for(int i=0; i<LEN; i++)Map[i].clear();
    memset(edg, 0, sizeof edg);
    for(int i=1; i<n; i++){
        for(int j=1; j<m; j++) edg[i][j+1][LEFT] = edg[i][j][RIGHT] = readi();
        for(int j=1; j<=m; j++) edg[i][j][DOWN] = edg[i+1][j][UP] = readi();
    }
    for(int i=1; i<m ;i++)edg[n][i+1][LEFT] = edg[n][i][RIGHT] = readi();
}

void buildmap()
{
    memset(id, 0 ,sizeof id);
    N = 0;
    //建立起点标号为0
    for(int i=0; i<4; i++)if(je(sx,sy,i)){
        Map[0].PB(MP(ch(sx+xx[i],sy+yy[i], i), edg[sx][sy][i]*2));
        Map[0].PB(MP(ch(sx+xx[i],sy+yy[i], 4), edg[sx][sy][i]*2));//书上说的走一步静止的情况
    }
    for(int i=1; i<=n; i++){
        for(int j=1; j<=m; j++){
            for(int k=0; k<4; k++){
                if(je(i,j,(k+2)%4)){
                    Map[ch(i,j,k)].PB(MP(ch(i,j,4),edg[i][j][(k+2)%4]));    //从走动到静止
                    if(je(i,j,k))Map[ch(i,j,k)].PB(MP(ch(i+xx[k],j+yy[k],k), edg[i][j][k]));//沿着一个方向比直走
                }
                if(je(i,j,k)){
                    Map[ch(i,j,4)].PB(MP(ch(i+xx[k],j+yy[k],k),edg[i][j][k]*2));//静止到转向
                    Map[ch(i,j,4)].PB(MP(ch(i+xx[k],j+yy[k],4),edg[i][j][k]*2));//静止到静止
                }
            }
        }
    }
}

int main()
{
//    freopen("in.txt", "r", stdin);

    int kase = 1;
    while(scanf("%d%d%d%d%d%d", &n, &m, &sx, &sy, &ex, &ey)==6 && n){
        readmap();
        buildmap();
        Dijkstra(0);
        int ans = dis[ch(ex,ey,4)];
        printf("Case %d: ", kase++);
        if(ans!=INF) printf("%d
", ans);
        else printf("Impossible
");
    }
    return 0;
}