二重价值的最短路

给你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

题意应该就不用说了。

讲讲题解：这道题我用了三种做法，其中两种一样，只是第三种是在第二种的基础上加以堆维护，尽管我c++不是很会，那个优先队列也不是很会，但还是能够处理这题的

第一种做法：Bellman-ford

思路：遍历所有的边，如果该边的两个节点其中一个已经求出到该点距离最小值，然后比较另外一个点的距离最小值和该点最小值到这另外一个点的距离和，取最小的更新这另外一个点的最小距离，直到最后不能更新为止。

代码：

#include <cstdio>
#include <iostream>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <queue>
#include <sstream>
#define INF 1e9
#define MAXN 150
#define mbit 70
using namespace std;
typedef long long ll;
int n,m,s,e;
struct Edge{int from,to,len,cost;} edge[100005];
struct D{int len,cost;} d[1005];
void solve(int a,int b)
{
    for (int i = 1;i <= n;i++)
        d[i].len = d[i].cost = INF;
    d[a].len = 0,d[a].cost = 0;
    while (1)
    {
        bool update = 0;
        for (int i = 0;i < m;i++)
        {
            if(d[edge[i].from].len!=INF)
            {
                if(d[edge[i].to].len>d[edge[i].from].len+edge[i].len)
                {
                    d[edge[i].to].len = d[edge[i].from].len+edge[i].len;
                    d[edge[i].to].cost = d[edge[i].from].cost+edge[i].cost;
                    update = 1;
                }
                else if(d[edge[i].to].len == d[edge[i].from].len+edge[i].len&&d[edge[i].to].cost > d[edge[i].from].cost+edge[i].cost)
                {
                    d[edge[i].to].cost = d[edge[i].from].cost+edge[i].cost;
                    update = 1;
                }
            }
            if(d[edge[i].to].len!=INF)
            {
                if(d[edge[i].from].len>d[edge[i].to].len+edge[i].len)
                {
                    d[edge[i].from].len = d[edge[i].to].len+edge[i].len;
                    d[edge[i].from].cost = d[edge[i].to].cost+edge[i].cost;
                    update = 1;
                }
                else if(d[edge[i].from].len == d[edge[i].to].len+edge[i].len&&d[edge[i].from].cost > d[edge[i].to].cost+edge[i].cost)
                {
                    d[edge[i].from].cost = d[edge[i].to].cost+edge[i].cost;
                    update = 1;
                }
            }
        }
        if(!update)
            break;
    }
    cout<<d[b].len<<" "<<d[b].cost<<endl;
}
int main(void)
{
    while (scanf("%d %d",&n,&m)!=EOF&&(n||m))
    {
        for (int i = 0;i < m;i++)
        {
            scanf("%d %d %d %d",&edge[i].from,&edge[i].to,&edge[i].len,&edge[i].cost);
        }
        scanf("%d %d",&s,&e);
        solve(s,e);
    }
}

第二种：dijkstra

思路：先从未标记的点中找出一个距离最小的点，一开始是初始化的话是起点的最短距离为0.，所以一开始选到的是起点，然后更新所有与该点相邻的点，然后一直这样操作，知道所有点都被标记完毕。

代码：

#include <cstdio>
#include <iostream>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <queue>
#include <sstream>
#define INF 1e9
#define MAXN 150
#define mbit 70
using namespace std;
typedef long long ll;
int n,m;
struct Edge{int a,b,c,d;}edge[100050];
struct D{int len,cost;}d[1005];
int used[1005];
void solve(int s,int e)
{
    for (int i = 1;i <= n;i++)
        d[i].len = d[i].cost = INF;
    d[s].len = d[s].cost = 0;
    memset(used,0,sizeof(used));
    while (1)
    {
        int v = -1;
        for (int i = 1;i <= n;i++)
        {
            if(!used[i]&&(v==-1||d[i].len<d[v].len))
                v = i;
        }
        if(v==-1)
            break;
        used[v] = 1;
        for (int i = 0;i < m;i++)
        {
            if(edge[i].a == v)
            {
                if(d[edge[i].b].len > d[edge[i].a].len+edge[i].c)
                {
                    d[edge[i].b].len = d[edge[i].a].len+edge[i].c;
                    d[edge[i].b].cost = d[edge[i].a].cost+edge[i].d;
                }
                else if(d[edge[i].b].len == d[edge[i].a].len+edge[i].c&&d[edge[i].b].cost > d[edge[i].a].cost+edge[i].d)
                {
                    d[edge[i].b].cost = d[edge[i].a].cost+edge[i].d;
                }
            }
            if(edge[i].b == v)
            {
                if(d[edge[i].a].len > d[edge[i].b].len+edge[i].c)
                {
                    d[edge[i].a].len = d[edge[i].b].len+edge[i].c;
                    d[edge[i].a].cost = d[edge[i].b].cost+edge[i].d;
                }
                else if(d[edge[i].a].len == d[edge[i].b].len+edge[i].c&&d[edge[i].a].cost > d[edge[i].b].cost+edge[i].d)
                {
                    d[edge[i].a].cost = d[edge[i].b].cost+edge[i].d;
                }
            }
        }
    }
    cout<<d[e].len<<" "<<d[e].cost<<endl;
}
int main(void)
{
    while(scanf("%d %d",&n,&m)!=EOF&&(n||m))
    {
        for (int i = 0;i < m;i++)
        {
            scanf("%d %d %d %d",&edge[i].a,&edge[i].b,&edge[i].c,&edge[i].d);
        }
        int s,e;
        scanf("%d %d",&s,&e);
        solve(s,e);
    }
    return 0;
}

第三种：堆优化的dijkstra

关键还是要用priority_queue<P,vector<P>,great<P> > que;这样的优先队列每次取出的是最小值

priority_queue<int> que;这样每次取出的是最大值

思路和第二种是一样的

代码

#include <cstdio>
#include <iostream>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <queue>
#include <sstream>
#define INF 1e9
#define MAXN 150
#define mbit 70
using namespace std;
typedef long long ll;
int n,m;
struct Edge{int a,b,c,d;}edge[100050];
struct D{int len,cost;}d[1005];
typedef pair<int ,int> P;
void solve(int s,int e)
{
    priority_queue<P,vector<P>,greater<P> > que;
    for (int i = 1;i <= n;i++)
        d[i].len = d[i].cost = INF;
    d[s].len = d[s].cost = 0;
    que.push(P(0,s));
    while (que.size())
    {
        P q;
        q = que.top();
        que.pop();
        if(d[q.second].len > q.first)
            continue;
        for (int i = 0;i < m;i++)
        {
            if(edge[i].a == q.second)
            {
                if(d[edge[i].b].len > q.first+edge[i].c)
                {
                    d[edge[i].b].len = q.first+edge[i].c;
                    d[edge[i].b].cost = d[edge[i].a].cost+edge[i].d;
                    que.push(P(d[edge[i].b].len,edge[i].b));
                }
                else if(d[edge[i].b].len == q.first+edge[i].c&&d[edge[i].b].cost > d[q.second].cost+edge[i].d)
                {
                    d[edge[i].b].cost = d[q.second].cost+edge[i].d;
                    que.push(P(d[edge[i].b].len,edge[i].b));
                }
            }
            if(edge[i].b == q.second)
            {
                if(d[edge[i].a].len > q.first+edge[i].c)
                {
                    d[edge[i].a].len = q.first+edge[i].c;
                    d[edge[i].a].cost = d[q.second].cost+edge[i].d;
                    que.push(P(d[edge[i].a].len,edge[i].a));
                }
                else if(d[edge[i].a].len == q.first+edge[i].c&&d[edge[i].a].cost > d[q.second].cost+edge[i].d)
                {
                    d[edge[i].a].cost = d[q.second].cost+edge[i].d;
                    que.push(P(d[edge[i].a].len,edge[i].a));
                }
            }
        }
    }
    cout<<d[e].len<<" "<<d[e].cost<<endl;
}
int main(void)
{
    while(scanf("%d %d",&n,&m)!=EOF&&(n||m))
    {
        for (int i = 0;i < m;i++)
        {
            scanf("%d %d %d %d",&edge[i].a,&edge[i].b,&edge[i].c,&edge[i].d);
        }
        int s,e;
        scanf("%d %d",&s,&e);
        solve(s,e);
    }
    return 0;
}