pta 编程题20 旅游规划

其它pta数据结构编程题请参见：pta

题目

这个最短路径问题只需要求两点之间的最短路径，因而在Dijikstra算法中当求出目标点的最短路径之后跳出循环即可。

#include <iostream>
using namespace std;

struct Node
{
    int length;
    int price;
};

int V, E;
Node **G;

void buildGraph();
void deleteGraph();
void dijkstra(int s, int d);
int findMinDist(Node* dist, bool* collected);
bool cmp(Node a, Node b);

int main()
{
    int S, D;
    cin >> V >> E >> S >> D;
    buildGraph();
    dijkstra(S, D);
    deleteGraph();
    return 0;
}

void buildGraph()
{
    int a, b, l, p, i;
    G = new Node*[V];
    for (a = 0; a < V; a++)
    {
        G[a] = new Node[V];
        for (b = 0; b < V; b++)
        {
            G[a][b].length = INT_MAX;
            G[a][b].price = INT_MAX;
        }
    }

    for (i = 0; i < E; i++)
    {
        cin >> a >> b >> l >> p;
        G[a][b].length = l;
        G[a][b].price = p;
        G[b][a].length = l;
        G[b][a].price = p;
    }
}

void deleteGraph()
{
    for (int i = 0; i < V; i++)
        delete[] G[i];
    delete[] G;
}

bool cmp(Node a, Node b)
{
    if (a.length != b.length)
        return a.length < b.length;
    else
        return a.price < b.price;
}

int findMinDist(Node* dist, bool* collected)
{
    int minV;
    Node minDist;
    minDist.length = INT_MAX;
    minDist.price = INT_MAX;

    for (int i = 0; i < V; i++)
    {
        if (!collected[i] && cmp(dist[i], minDist))
        {
            minDist = dist[i];
            minV = i;
        }
    }

    if (minDist.length == INT_MAX)
        return -1;
    else
        return minV;
}

void dijkstra(int s, int d)
{
    int v, w;
    Node *dist, temp;
    bool *collected;
    dist = new Node[V];
    collected = new bool[V];
    for (v = 0; v < V; v++)
    {
        dist[v] = G[s][v];
        collected[v] = false;
    }

    dist[s].length = 0;
    dist[s].price = 0;
    collected[s] = true;

    while (true)
    {
        v = findMinDist(dist, collected);
        if (v == d) break;
        collected[v] = true;

        for (w = 0; w < V; w++)
        {
            if (!collected[w] && G[v][w].length < INT_MAX)
            {
                temp.length = dist[v].length + G[v][w].length;
                temp.price = dist[v].price + G[v][w].price;
                if (cmp(temp, dist[w]))
                    dist[w] = temp;
            }
        }
    }

    cout << dist[d].length << " " << dist[d].price;
    delete dist;
    delete collected;
}