UVALive 4128 Steam Roller(最短路（拆点，多状态）)

题意：模拟了汽车的行驶过程，边上的权值为全速通过所消耗的时间，而起步（从起点出发的边）、刹车（到终点结束的边）、减速（即将拐弯的边）、加速（刚完成拐弯的边）这四种不能达到全速的情况，消耗的时间为权值*2。问从起点到终点所消耗的最少时间。

这道题主要是建图，很复杂，无耻地照着书上的代码码了一遍。让状态搞糊涂了= =

注意：

1、grid[][][4]记录了点的上下左右四条边的权值，id[][][4][2]记录各个点。

2、到一个点的最短路可以是路过这个点再折返回来，e.g：1->2 c=17，2->3 c=4，从1->2的最短路为17+8+8=33<34

3、原图总点数上限100*100，而拆点后共有8*100*100个点，狠狠地RE了一发。

 #include<cstdio>
 #include<cstring>
 #include<vector>
 #include<queue>
 #include<algorithm>
 using namespace std;

 const int MAXN=;
 const int maxr=,maxc=;
 const int INF =1e9;

 const int UP=,LEFT=,DOWN=,RIGHT=;
 const int inv[]={,,,};
 const int dr[]={-,,,};
 const int dc[]={,-,,};

 struct Edge{
     int u,v,c;
 };

 struct HeapNode{
     int c,u;
     bool operator < (const HeapNode rhs)const {
         return c>rhs.c;
     }
 };

 struct Dijkstra{
     int n,m;
     vector<Edge>edges;
     vector<int>G[MAXN];
     bool vis[MAXN];
     int d[MAXN],p[MAXN];

     void init(int n)
     {
         this->n=n;
         for(int i=;i<n;i++)
             G[i].clear();
         edges.clear();
     }

     void add(int u,int v,int c)
     {
         edges.push_back((Edge){u,v,c});
         m=edges.size();
         G[u].push_back(m-);
     }

     void dijkstra(int st)
     {
         priority_queue<HeapNode>q;
         for(int i=;i<n;i++)
             d[i]=INF;
         d[st]=;
         memset(vis,,sizeof(vis));
         q.push((HeapNode){,st});
         while(!q.empty())
         {
             HeapNode x=q.top();q.pop();
             int u=x.u;
             if(vis[u])
                 continue;
             vis[u]=true;
             int sz=G[u].size();
             for(int i=;i<sz;i++)
             {
                 Edge e=edges[G[u][i]];
                 if(d[e.v]>d[u]+e.c){
                     d[e.v]=d[u]+e.c;
                     q.push((HeapNode){d[e.v],e.v});
                 }
             }
         }
     }
 };

 int grid[maxr][maxc][];

 int n,id[maxr][maxc][][];

 int ID(int r,int c,int dir,int doubled)
 {
     int& x=id[r][c][dir][doubled];
     if(x==)x=++n;
     return x;
 }

 int R,C;

 bool cango(int r,int c,int dir)
 {
     if(r<||r>=R||c<||c>=C)
         return false;
     return grid[r][c][dir]>;
 }

 Dijkstra solver;

 int readint()
 {
     int x;
     scanf("%d",&x);
     return x;
 }

 int main()
 {
     int r1,c1,r2,c2,kase=;
     while(scanf("%d%d%d%d%d%d",&R,&C,&r1,&c1,&r2,&c2)==&&R)
     {
         r1--;c1--;r2--;c2--;
         memset(grid,,sizeof(grid));
         for(int r=;r<R;r++)//每次更新点(r,c)的下方和右方的边
         {
             for(int c=;c<C-;c++)
                 grid[r][c][RIGHT]=grid[r][c+][LEFT]=readint();
             if(r!=R-)
                 for(int c=;c<C;c++)
                     grid[r][c][DOWN]=grid[r+][c][UP]=readint();
         }

         solver.init(R*C*+);

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

         for(int dir=;dir<;dir++)//对起点做double
             if(cango(r1,c1,dir))
                 solver.add(,ID(r1+dr[dir],c1+dc[dir],dir,),grid[r1][c1][dir]*);

         for(int r=;r<R;r++)//要把所有点都处理完整，不能到r2,c2就结束
             for(int c=;c<C;c++)
                 for(int dir=;dir<;dir++)
                     if(cango(r,c,inv[dir]))
                         //为什么是inv？grid[r][c][inv[dir]]是点(r,c)沿inv[dir]方向到点x的边权，同样也是点x->点(r,c)的边权:老边
                         //而区别在于判断进入(r,c)的边，与出(r,c)进(new,r,newc)的边方向是否一致
                         for(int newdir=;newdir<;newdir++)
                             if(cango(r,c,newdir))
                                 for(int doubled=;doubled<;doubled++){
                                     int newr=r+dr[newdir];
                                     int newc=c+dc[newdir];
                                     int v=grid[r][c][newdir],newdoubled=;
                                     if(dir!=newdir){//若方向不一致，两条边都要加倍
                                         if(!doubled)//对于前一条边分两种情况讨论：已经double（之前已经加速或起步），未double
                                             v+=grid[r][c][inv[dir]];//
                                         newdoubled=;
                                         v+=grid[r][c][newdir];
                                     }
                                     solver.add(ID(r,c,dir,doubled),ID(newr,newc,newdir,newdoubled),v);
                                     //若方向一致，连到newdouble==0的两条边权值相同
                                     //否则，连到newdouble==1的两条边相差grid[r][c][inv[dir]],即分开讨论老边是否已加倍，由于最后求最短路，不影响
                                 }
         solver.dijkstra();

         int ans=INF;
         for(int dir=;dir<;dir++)//从与终点(r2,c2)相连的八个状态中取最小值
             if(cango(r2,c2,inv[dir]))
                 for(int doubled=;doubled<;doubled++)
                 {
                     int v=solver.d[ID(r2,c2,dir,doubled)];
                     if(!doubled)
                         v+=grid[r2][c2][inv[dir]];
                     ans=min(ans,v);
                 }

         printf("Case %d: ",++kase);
         if(ans==INF)
             printf("Impossible\n");
         else
             printf("%d\n",ans);
     }
     return ;
 }

后记：

　　这里的数组id[][][][]，以及函数 ID()的处理很值得学习一下。在处理多状态等复杂情况是很实用。

　　用这个方法自己写了一道题，一遍就通过了样例，好有成就感，可惜uva在这道题上又挂了= =