MST:Roadblocks(POJ 3255)

　　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　    路上的石头

　　题目大意：某个街区有R条路，N个路口，道路双向，问你从开始（1）到N路口的次短路经长度，同一条边可以经过多次。

　　这一题相当有意思，现在不是要你找最短路径，而是要你找次短路经，而且次短路经同一条可以经过多次，用Dijkstra的方法最短路是只会经过一条边的。

　　但是别急，我们次短路经也是建立在最短路径上的，那么其实我们完全可以用最短路径的算法来解决这个问题，但是要修改一下算法，这里用Dijkstra算法（没有负边），我们设定两个区域，一个是最短路径区域，一个是次短路径区域，问题来了，怎么更新这两个区域呢？

　　首先最短路径区域更新的方法是一样的，次短路经怎么办？我们可以根据次短路经是上一条最短路径+本次路径次短边来完成这个操作，但是上一次最短路径可以是多条，所以我们就要想想办法了，其实在这里我们可以把以前我们熟悉的Dijkstra算法的known域去掉，那样我们就可以不用受“节点只能经过一次”的限制了，而且也实现了一条边可以经过多次，而且我们会把节点多次入堆，节点不再是纯粹的单节点了，而是一个临时节点（即最短路径和次短路经都是临时的，但是我们只用维护最短的就可以了），实现对路径的选择（而不是节点）

　　那么更新的时候我们围绕次短路经来裁剪选择就可以了，当目标节点的当前次短路经比临时的最短路径还要大，那就不必搜索了。

　　所以这题千万不能用以前那个旧方法，我就生搬硬套，没有考虑到次短路经不能第一时间维护，所以导致多次wa，心疼

　　

 #include <iostream>
 #include <functional>
 #include <algorithm>
 #include <queue>
 #define MAX 5004
 #define MAX_E 100005

 using namespace std;
 typedef int Position;

 typedef struct map//向前边方法储存邻接表
 {
     int cost;
     Position to;
     int next;

 }Edge;
 typedef struct node_
 {
     Position point;
     Position v;
     int cost;//最短路径
     bool operator<(const node_ &x)const
     {
         return cost > x.cost;
     }

 }Node;

 static Edge edge[MAX_E * ];
 static Node head[MAX];
 static int Dist_Min[MAX], Dist_last_min[MAX];

 void Dijkstra(const int);
 void Swap(int *const, int *const);

 int main(void)
 {
     int Node_Sum, Road_Sum, from, to, tmp_cost;
     while (~scanf("%d%d", &Node_Sum, &Road_Sum))
     {

         for (int i = ; i <= Node_Sum; i++)
         {
             head[i].v = i;
             head[i].point = -;
         }
         for (int i = ; i < Road_Sum * ; i += )//向前边法储存邻接表
         {
             scanf("%d%d%d", &from, &to, &tmp_cost);

             edge[i].next = head[from].point; edge[i].to = to; edge[i].cost = tmp_cost;
             head[from].point = i;
             edge[i + ].next = head[to].point; edge[i + ].to = from; edge[i + ].cost = tmp_cost;
             head[to].point = i + ;
         }
         Dijkstra(Node_Sum);
     }
     return ;
 }

 void Swap(int *const a, int *const b)
 {
     *a ^= *b;
     *b ^= *a;
     *a ^= *b;
 }

 void Dijkstra(const int Node_Sum)
 {
     int out, v, k, dist, d_out;
     Edge e_tmp; Node Node_tmp;

     fill(Dist_last_min + , Dist_last_min + Node_Sum + , 0x7fffffff);
     fill(Dist_Min + , Dist_Min + Node_Sum + , 0x7fffffff);

     priority_queue<Node> que;
     Dist_Min[] = ;
     Node_tmp.v = ; Node_tmp.cost = ; Node_tmp.point = head[].point;
     que.push(Node_tmp);

     while (!que.empty())//Diskstra算法还可以找次短路
     {
         Node_tmp = que.top(); que.pop();

         out = Node_tmp.v; d_out = Node_tmp.cost;
         if (d_out > Dist_last_min[out]) continue;//千万不要简单的就直接用以前的方法固定min_dist，因为
         for (k = Node_tmp.point; k != -; k = edge[k].next)
         {
             e_tmp = edge[k]; v = e_tmp.to;
             dist = d_out + e_tmp.cost;
             if (dist < Dist_Min[v])
             {
                 Swap(&dist, &Dist_Min[v]);//注意一定是交换！
                 Node_tmp.v = v; Node_tmp.cost = Dist_Min[v]; Node_tmp.point = head[v].point;
                 que.push(Node_tmp);
             }
             if (dist < Dist_last_min[v] && dist > Dist_Min[v])
             {
                 Dist_last_min[v] = dist;
                 Node_tmp.v = v; Node_tmp.cost = Dist_last_min[v]; Node_tmp.point = head[v].point;
                 que.push(Node_tmp);//这里会造成v多次入堆，需要做特判
             }
         }
     }
     printf("%d\n", Dist_last_min[Node_Sum]);
 }