HDU 3790 最短路径问题 (最短路)

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3790

简单的最短路问题，这题听说有重边。我用spfa和dijkstra写了一遍，没判重边，速度都差不多。

dijkstra+优先队列：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <queue>
 #include <vector>
 using namespace std;
 const int INF = 1e9 + ;
 struct Node {
     int _node , _dis , _cost;
     bool operator <(const Node &cmp) const {
         if(_dis == cmp._dis)
             return _cost > cmp._cost;
         return _dis > cmp._dis;
     }
 };
 struct Edge {
     int to , _dis , _cost , next;
 }edge[int(2e5 + )];
 int dis[] , cost[] , head[] , cnt;

 inline void add(int u , int v , int _dis , int _cost) {
     edge[cnt].next = head[u];
     edge[cnt].to = v;
     edge[cnt]._cost = _cost;
     edge[cnt]._dis = _dis;
     head[u] = cnt++;
 }

 void dijkstra(int s) {
     dis[s] = cost[s] = ;
     priority_queue <Node> que;
     while(!que.empty()) {
         que.pop();
     }
     que.push(Node{s ,  , });
     while(!que.empty()) {
         Node temp = que.top();
         que.pop();
         int u = temp._node;
         if(temp._dis > dis[u])
             continue;
         for(int i = head[u] ; ~i ; i = edge[i].next) {
             int v = edge[i].to;
             if(dis[v] > dis[u] + edge[i]._dis) {
                 dis[v] = dis[u] + edge[i]._dis;
                 cost[v] = cost[u] + edge[i]._cost;
                 que.push(Node{v , dis[v] , cost[v]});
             }
             else if(dis[v] == dis[u] + edge[i]._dis && cost[v] > cost[u] + edge[i]._cost) {
                 cost[v] = cost[u] + edge[i]._cost;
                 que.push(Node{v , dis[v] , cost[v]});
             }
         }
     }
 }

 int main()
 {
     int n , m , u , v , d , c;
     while(~scanf("%d %d" , &n , &m) && (n || m)) {
         for(int i =  ; i <= n ; ++i)
             cost[i] = dis[i] = INF;
         memset(head , - , sizeof(head));
         cnt = ;
         while(m--) {
             scanf("%d %d %d %d" , &u , &v , &d , &c);
             add(u , v , d , c);
             add(v , u , d , c);
         }
         scanf("%d %d" , &u , &v);
         dijkstra(u);
         printf("%d %d\n" , dis[v] , cost[v]);
     }
     return ;
 }

spfa：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <vector>
 #include <queue>
 using namespace std;
 const int INF = 1e9 + ;
 typedef pair <int , pair<int , int> > P; //邻接点 长度 花费
 int dis[] , cost[];
 vector <P> G[];
 void spfa(int s) {
     dis[s] = cost[s] = ;
     queue <int> que;
     while(!que.empty()) {
         que.pop();
     }
     que.push(s);
     while(!que.empty()) {
         int node = que.front();
         que.pop();
         for(int i =  ; i < G[node].size() ; ++i) {
             int temp = G[node][i].first;
             if(dis[temp] > dis[node] + G[node][i].second.first) {
                 dis[temp] = dis[node] + G[node][i].second.first;
                 cost[temp] = cost[node] + G[node][i].second.second;
                 que.push(temp);
             }
             else if(dis[temp] == dis[node] + G[node][i].second.first && cost[temp] > cost[node] + G[node][i].second.second) {
                 cost[temp] = cost[node] + G[node][i].second.second;
                 que.push(temp);
             }
         }
     }
 }

 int main()
 {
     int n , m , u , v , d , c;
     while(~scanf("%d %d" , &n , &m) && (n || m)) {
         for(int i =  ; i <= n ; ++i) {
             dis[i] = cost[i] = INF;
             G[i].clear();
             for(int j = i +  ; j <= n ; ++j)
                 to[i][j] = to[j][i] = INF;
         }
         for(int i =  ; i < m ; ++i) {
             scanf("%d %d %d %d" , &u , &v , &d , &c);
             G[u].push_back(P(v , make_pair(d , c)));
             G[v].push_back(P(u , make_pair(d , c)));
         }
         scanf("%d %d" , &u , &v);
         spfa(u);
         printf("%d %d\n" , dis[v] , cost[v]);
     }
     return ;
 }