Road Construction Aizu - 2249（dijkstra+ 连接表）

Road Construction

King Mercer is the king of ACM kingdom. There are one capital and some cities in his kingdom. Amazingly, there are no roads in the kingdom now. Recently, he planned to construct roads between the capital and the cities, but it turned out that the construction cost of his plan is much higher than expected.
In order to reduce the cost, he has decided to create a new construction plan by removing some roads from the original plan. However, he believes that a new plan should satisfy the following conditions:

For every pair of cities, there is a route (a set of roads) connecting them.
The minimum distance between the capital and each city does not change from his original plan.

Many plans may meet the conditions above, but King Mercer wants to know the plan with minimum cost. Your task is to write a program which reads his original plan and calculates the cost of a new plan with the minimum cost.
Input
The input consists of several datasets. Each dataset is formatted as follows.
N M
u1 v1 d1 c1
.
.
.
uM vM dM cM

The first line of each dataset begins with two integers, N and M (1 ≤ N ≤ 10000, 0 ≤ M ≤ 20000). N and M indicate the number of cities and the number of roads in the original plan, respectively.
The following M lines describe the road information in the original plan. The i-th line contains four integers, ui, vi, di and ci (1 ≤ ui, vi ≤ N , ui ≠ vi , 1 ≤ di ≤ 1000, 1 ≤ ci ≤ 1000). ui , vi, di and ci indicate that there is a road which connects ui-th city and vi-th city, whose length is di and whose cost needed for construction is ci.
Each road is bidirectional. No two roads connect the same pair of cities. The 1-st city is the capital in the kingdom.
The end of the input is indicated by a line containing two zeros separated by a space. You should not process the line as a dataset.
Output
For each dataset, print the minimum cost of a plan which satisfies the conditions in a line.
Sample Input
3 3
1 2 1 2
2 3 2 1
3 1 3 2
5 5
1 2 2 2
2 3 1 1
1 4 1 1
4 5 1 1
5 3 1 1
5 10
1 2 32 10
1 3 43 43
1 4 12 52
1 5 84 23
2 3 58 42
2 4 86 99
2 5 57 83
3 4 11 32
3 5 75 21
4 5 23 43
5 10
1 2 1 53
1 3 1 65
1 4 1 24
1 5 1 76
2 3 1 19
2 4 1 46
2 5 1 25
3 4 1 13
3 5 1 65
4 5 1 34
0 0

Output for the Sample Input
3
5
137
218

题意：
已知每条道路的距离，费用。
求1到每个点的最短路程的最小费用和（重复的道路不记）

看似为最小生成树，其实不是。
prim（）生成最短生成树，不能保证每两点都是最短距离（例如：1到2距离2，2到3距离2，1到3距离3，最小生成树为4，走最短距离所经过的最小距离和为3）

题解：
用dijkstra算法求得1到每个点的最短距离mindis，顺便记录最短费用mincost

#include <cmath>
#include <cstdio>
#include <algorithm>
#include <iostream>
#include <vector>
#include <queue>
#define P pair<int, int>
using namespace std;
const int MAX = 1e4 + 5;
int INF = 0x3f3f3f3f;

struct edge{
	int to;
	int dis, cost;
};

vector<edge> G[MAX];
int mindis[MAX];
int mincost[MAX];
int N, M;

void dijkstra() {
    for(int i = 0; i < N; i++) {
        mindis[i] = INF;
        mincost[i] = 0;
    }
    mindis[0] = 0;
    priority_queue<P, vector<P>, greater<P > > que;
    que.push(P(0,0));
    while(que.size()) {
        P qu = que.top();
        que.pop();
        int v = qu.second;
        if(mindis[v] < qu.first) continue;
        for(int i = 0; i < (int)G[v].size(); i++) {
            edge e = G[v][i];
            if(mindis[e.to] >= e.dis + mindis[v]) {
                if(mindis[e.to] == e.dis + mindis[v])//距离相等，则取费用少的
                    mincost[e.to] = min(mincost[e.to], e.cost);
                else
                    mincost[e.to] = e.cost;
                mindis[e.to] = e.dis + mindis[v];
                que.push(P(mindis[e.to], e.to));
            }
        }
    }
}

int main() {
    while(scanf("%d%d", &N, &M) != EOF) {
        if(N == 0 && M == 0) break;
        for(int i = 0; i < N; i++)
            G[i].clear();
        for(int i = 0; i < M; i++) {
            int a, b, c, d;
            scanf("%d%d%d%d", &a, &b, &c, &d);
            a--, b--;
            edge e1, e2;
            e1.to = b, e1.dis = c, e1.cost = d;
            e2.to = a, e2.dis = c, e2.cost = d;
            G[a].push_back(e1);
            G[b].push_back(e2);
        }
        dijkstra();
        long long ans = 0;
        for(int i = 0; i < N; i++){
            ans += mincost[i];
        }
        printf("%lld\n", ans);
    }
}