最短路径问题 HDU - 3790 (Dijkstra算法 + 双重权值)

参考：https://www.cnblogs.com/qiufeihai/archive/2012/03/15/2398455.html

最短路径问题

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 2622    Accepted Submission(s): 825

Problem Description

给你n个点，m条无向边，每条边都有长度d和花费p，给你起点s终点t，要求输出起点到终点的最短距离及其花费，如果最短距离有多条路线，则输出花费最少的。

 

Input

输入n,m，点的编号是1~n,然后是m行，每行4个数 a,b,d,p，表示a和b之间有一条边，且其长度为d，花费为p。最后一行是两个数 s,t;起点s，终点。n和m为0时输入结束。
(1<n<=1000, 0<m<100000, s != t)

 

Output

输出 一行有两个数， 最短距离及其花费。

 

Sample Input

3 2

1 2 5 6

2 3 4 5

1 3

0 0

 

Sample Output

9 11

 

 

注意点： 题中所给的输入数据有可能有多条长度相等，但花费不同的数据，在输入处理的时候需要进行判断，选出花费最少的情况！

 

 #include <stdio.h>
 #include <iostream>
 #include <cstring>
 #include <vector>
 #include <algorithm>
 #include <sstream>

 #define INF 1000000000

 using namespace std;

 int dis[];
 int vis[];
 int cost[];
 int n, m;

 struct node
 {
     int len;
     int cost;
 }g[][];

 void dijkstra(int start)
 {
     for(int i = ; i <= n; ++i)
     {
         dis[i] = INF;
         cost[i] = INF;
     }
     dis[start] = ;
     cost[start] = ;

     while()
     {
         int mark = -, minDis = INF;
         for(int i = ; i <= n; ++i)
         {
             if(!vis[i] && dis[i] < minDis)
             {
                 minDis = dis[i];
                 mark = i;
             }
         }

         if(mark == -)
             break;
         vis[mark] = ;

         for(int i = ; i <= n; ++i)
         {
             if(!vis[i])
             {
                 if(dis[mark] + g[mark][i].len < dis[i])
                 {
                     dis[i] = dis[mark] + g[mark][i].len;
                     cost[i] = cost[mark] + g[mark][i].cost;
                 }
                 else if(dis[mark] + g[mark][i].len == dis[i] && cost[i] > cost[mark] + g[mark][i].cost)
                 {
                     cost[i] = cost[mark] + g[mark][i].cost;
                 }

             }
         }

     }
 }

 int main()
 {
     while(scanf("%d %d", &n, &m) != EOF)
     {
         if(n ==  && m == )
             break;

         memset(vis, , sizeof(vis));
         for(int i = ; i <= n; ++i)
             for(int j = ; j <= n; ++j)
             {
                 if(i == j)
                     g[i][j].len = ;
                 else
                     g[i][j].len = INF;
             }

         int a, b, d, p;
         for(int i = ; i <= m; ++i)
         {
             scanf("%d %d %d %d", &a, &b, &d, &p);
         /*    g[a][b].len = g[b][a].len = d;
             g[a][b].cost = g[b][a].cost = p;*/  //这样写会出错，必须下面那样写，因为有可能有长度相同但花费不同的边 

             if(g[a][b].len > d)
             {
                 g[a][b].len = g[b][a].len = d;
                 g[a][b].cost = g[b][a].cost = p;
             }

             // 这里很重要！！
             if(g[a][b].len == d && g[a][b].cost > p)     // 如果长度相等，则存放较少的费用
             {
                 g[a][b].cost = g[b][a].cost = p;
             }
         }

         int s, t;
         scanf("%d %d", &s, &t);
         dijkstra(s);

         cout << dis[t]  << " " << cost[t] << endl;
     }

     return ;
 }