九度oj题目1008：最短路径问题

题目描述：                       

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

输入：                       

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

输出：                       

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

样例输入：                       

3 2
1 2 5 6
2 3 4 5
1 3
0 0

样例输出：                       

9 11
通过这道题复习了一下迪杰特斯拉算法，算法的精髓在于每回找一个距离集合最近的点加到集合中，直到不能加入更多的点为止
代码如下：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <algorithm>
#define MAX 999999999
#define N 1005
#define M 100005

struct Way {
    int distance;
    int cost;
};

Way map[N][N];//邻接矩阵
Way dis[N];//起点到各个点的距离表
int flag[N];//判别某点是否在已包括点的集合中

void dijkstra(int start, int end,int n) {
    memset(flag,0,sizeof(int)*N);
    //初始化距离
    for(int i = 1; i <= n; i++) {
        dis[i] = map[start][i];
    }
    dis[start].distance = 0;//该点到自己的距离为0
    dis[start].cost = 0;//到自己的花费为0
    flag[start] = 1;//把自己包括到可以到达的点中

    for(int i = 1; i < n; i++) {
        //总共需要加入n-1个点，所以循环n-1次
        int index = 0;
        int min = MAX;
        for(int j = 1; j <= n; j++) {
            if(flag[j] == 0 && dis[j].distance < min) {
                index = j;
                min = dis[j].distance;
            }
        }
        //find the min index
        flag[index] = 1;

        for(int j = 1; j <= n; j++) {
            if(flag[j] == 0 && (dis[index].distance + map[index][j].distance < dis[j].distance)) {
                dis[j].distance = dis[index].distance + map[index][j].distance;
                dis[j].cost = dis[index].cost + map[index][j].cost;
            }
            else if(flag[j] == 0 && (dis[index].distance + map[index][j].distance == dis[j].distance)){
                if(dis[j].cost > dis[index].cost + map[index][j].cost) {
                    dis[j].cost = dis[index].cost + map[index][j].cost;
                }
            }
        }
    }

    
}

int main(int argc, char const *argv[])
{
    int n,m;
    int source, des;
    scanf("%d %d",&n,&m);
    while(n != 0 && m != 0) {
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= n; j++) {
                map[i][j].distance = MAX;
                map[i][j].cost = MAX;
            }
        }
        int pointA,pointB,disc,cost;
        for(int i = 0; i < m; i++) {
            scanf("%d %d %d %d",&pointA,&pointB,&disc,&cost);
            map[pointA][pointB].distance = disc; 
            map[pointB][pointA].distance = disc;
            map[pointA][pointB].cost = cost;
            map[pointB][pointA].cost = cost;
        }
        scanf("%d %d",&source,&des);

        dijkstra(source,des,n);
        printf("%d %d\n",dis[des].distance,dis[des].cost);
        scanf("%d %d",&n,&m);
    }
    return 0;
}

 最近尝试了一下用优先队列来解决问题，感觉写得很别扭，不过还是写出来了，速度提高不少，代码如下

#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>

#define MAX_V 1002
#define inf 999999999
using namespace std;

struct Edge
{
public:
    int to;
    int dis;
    int cost;
    Edge(int to, int dis,int cost) {
        this->to = to;
        this->dis = dis;
        this->cost = cost;
    }
};

struct cmp{
    bool operator()(const Edge &a,const Edge &b){
        if(a.dis == b.dis) {
            return a.cost - b.cost;
        }
        else {
            return a.dis - b.dis;
        }
    }
};
typedef pair<int , int> P;//first dis, sencond cost
P dist[MAX_V];
vector<Edge> G[MAX_V];
priority_queue<Edge, vector<Edge>, cmp> que;

int main(int argc, char const *argv[])
{
    int n,m;
    int source, des;
    freopen("input.txt","r",stdin);
    while(scanf("%d %d",&n,&m) != EOF && (n != 0 && m != 0)) {
        for(int i = 0; i <= n; i++) {
            G[i].clear();
        }
        for(int i = 0; i < m; i++) {
            int a, b, disc, cost;
            scanf("%d %d %d %d",&a,&b,&disc,&cost);
            G[a].push_back(Edge(b,disc,cost));
            G[b].push_back(Edge(a,disc,cost));
        }
        scanf("%d %d",&source,&des);
        fill(dist,dist+n+1,P(inf,inf));
        dist[source] = P(0,0);
        que.push(Edge(source,0,0));

        while(!que.empty()) {
            Edge t = que.top(); que.pop();
            int v = t.to, d = t.dis, c = t.cost;
            if(dist[v].first < d) {
                continue;
            }
            for(int i = 0; i < G[v].size(); i++) {
                Edge &e = G[v][i];
                int d2 = d + e.dis;
                int c2 = c + e.cost;

                if(dist[e.to].first > d2 || (dist[e.to].first == d2 && dist[e.to].second > c2)) {
                    dist[e.to] = P(d2,c2);
                    que.push(Edge(e.to,d2,c2));
                }
            }
        }
        printf("%d %d\n",dist[des].first,dist[des].second);

    }
    return 0;
}