问题 E: 最短路径问题

题目描述

 

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

 

输出

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

 

样例输入

<span style="color:#333333">3 2
1 2 5 6
2 3 4 5
1 3
0 0
</span>

样例输出

<span style="color:#333333">9 11</span>

提示

 

拿到这题，第一印象就是最短路劲问题（题目写得清清楚楚）。当然，你可以直接套用最短路劲的解法。不过这里我要给大家介绍另一种解法，同样是图论里的算法——深度优先搜索。

 

 

从起点开始进行深度优先搜索，当搜索的结点到达终点时查看路径总长度与花费是否比已经得到的最短路径和最小花费小，如果要小的话就使用当前的路径和花费取代最短路径和最小花费。

 

当遍历到终点时是否就结束了？非也，还需要从其他路径遍历，判断其他路径是否又更短花费更小的。这里就需要用到回溯了。所谓回溯，就是还需要往回走来走其他的路径。那么会不会进入循环状态呢？对遍历过的结点进行标记就能够杜绝循环。当然需要在回溯时取消之前的标记。

 

法一:Dijkstra + DFS

#include <iostream>
#include <vector>
#include <algorithm>
#define MAX_SIZE 1002
#define INF 10000000
using namespace std;
 
struct Way
{
    int length;
    int cost;
    Way()
    {
        length = INF;
        cost = INF;
    }
};
int n, m, mini_cost =INF, lessWay;
Way map[MAX_SIZE][MAX_SIZE];
bool vis[MAX_SIZE] = {false};
int ds[MAX_SIZE], cs[MAX_SIZE];
vector<int> pre[MAX_SIZE], temp;
 
void dijkstra(int s, int t)
{
    int i, j;
    lessWay = INF;
    fill(ds, ds + MAX_SIZE, INF);
    fill(cs, cs + MAX_SIZE, INF);
    ds[s] = 0;
    for (i = 1; i <= n; i++)
    {
        int u = -1, mini = INF;
        for (j = 1; j <= n; j++)
        {
            if (!vis[j] && ds[j] < mini)
            {
                u = j;
                mini = ds[j];
            }
        }
 
        if (u == -1)
            return;
        vis[u] = true;
        for (j = 1; j <= n; j++)
        {
            if (!vis[j] && map[u][j].length != INF)
            {
                if (ds[u] + map[u][j].length < ds[j])
                {
                    ds[j] = ds[u] + map[u][j].length;
                    pre[j].clear();
                    pre[j].push_back(u);
                }
                else if (ds[u] + map[u][j].length == ds[j])
                {
                    pre[j].push_back(u);
                }
            }
        }
    }
    lessWay = ds[t];
}
void dfs(int now, int s)
{
    if (now == s)
    {
        int cost = 0;
        for (int i = temp.size() - 1; i >0 ; i--)
        {
            cost += map[temp[i]][temp[i-1]].cost;
        }
        if (cost < mini_cost)
        {
            mini_cost = cost;
        }
        return;
    }
    for (int i = 0; i < pre[now].size(); i++)
    {
        temp.push_back(pre[now][i]);
        dfs(pre[now][i], s);
    }
    temp.pop_back();
}
void init()
{
    mini_cost = INF;
    temp.clear();
    for (int i = 1; i < MAX_SIZE; i++)
    {
        for (int j = 1; j < MAX_SIZE; j++)
        {
            map[i][j].length = INF;
            map[i][j].cost = INF;
        }
        pre[i].clear();
    }
}
int main()
{
    int i, a, b, s, t, d, p;
    Way way;
    while (cin >> n >> m && (n != 0 || m != 0))
    {
 
        fill(vis, vis + MAX_SIZE, false);
        for (i = 1; i <= m; i++)
        {
            cin >> a >> b >> d >> p;
            map[a][b].length = d;
            map[b][a].length = d;
            map[a][b].cost = p;
            map[b][a].cost = p;
        }
        cin >> s >> t;
        dijkstra(s, t);
        temp.push_back(t);
        dfs(t, s);
        cout << lessWay << " " << mini_cost << endl;
        init();
    }
    return 0;
}
 
/**************************************************************
    Problem: 1988
    User: morizunzhu
    Language: C++
    Result: 正确
    Time:20 ms
    Memory:9900 kb
****************************************************************/

法二