最短路径问题 HDU

参考：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[1002];
int vis[1002];
int cost[1002];
int n, m;

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

void dijkstra(int start)
{
    for(int i = 1; i <= n; ++i)
    {
        dis[i] = INF;
        cost[i] = INF;
    }
    dis[start] = 0;
    cost[start] = 0;
    
    while(1)
    {
        int mark = -1, minDis = INF;
        for(int i = 1; i <= n; ++i)
        {
            if(!vis[i] && dis[i] < minDis)
            {
                minDis = dis[i];
                mark = i;
            }
        }
        
        if(mark == -1)
            break;
        vis[mark] = 1;
        
        for(int i = 1; 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 == 0 && m == 0)
            break;
        
        memset(vis, 0, sizeof(vis));
        for(int i = 1; i <= n; ++i)
            for(int j = 1; j <= n; ++j)
            {
                if(i == j)
                    g[i][j].len = 0;
                else
                    g[i][j].len = INF;
            }
        
        int a, b, d, p;    
        for(int i = 1; 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 0;
}