春游分数 10

春游
分数 10

春天阳光灿烂，小宋突然心血来潮想骑自行车去学校外面玩，但是到达目的地的路线不止一条，他想尽快的到达目的地，又能不需要骑太远的路， 你能帮助他吗？

输入格式:
输入包含一个测试数据，第一行有三个整数n(2 <= n <= 1000)，途中可能经过的地点的个数，地点编号1~n；m(1 <= m <= 10000)，为路径的条数；d(2 <= d <= n)，目的地编号；其中学校为起点，默认为1。接下来m行： x y time dist ， x y表示地点x，y是可以相互到达的，time，dist分别表示x到y或y到x的时间，距离。

输出格式:
按如下格式输出“花费的时间+空格+要骑的距离+空格+从学校到达目的地的路径”，路径中的两个地点之间以箭头（->）分隔。（具体见输出样例）

输入样例:
在这里给出一组输入。例如：

7 8 7
1 2 1 1
1 3 1 1
2 4 1 2
3 4 1 1
4 5 1 2
4 6 1 1
5 7 1 1
6 7 2 1
输出样例:
在这里给出相应的输出。例如：

 

 

4 5 1->3->4->5->7

#include <iostream> // 包含输入输出流的头文件
#include <algorithm> // 包含算法操作的头文件
#define INFTY 1<<21 // 定义无穷大的值，用于初始化图中边的权重
using namespace std; // 使用标准命名空间

// 定义一个结构体来存储时间和距离
typedef struct _Weight {
    int Time; // 时间权重
    int dist; // 距离权重
} Weight;

// 定义图的邻接矩阵，节点数不超过10000
Weight G[10001][10001];
int pre[10001]; // 用来记录最短路径的前驱节点

// Dijkstra算法的实现
void Dijkstra(int Dist[], int n, int Time[]) {
    int visited[n + 1]; // 标记数组，表示节点是否被访问过
    // 初始化所有节点的访问状态和距离信息
    for(int i = 1; i < n + 1; i++) {
        visited[i] = 0;
        Dist[i] = INFTY;
        Time[i] = INFTY;
    }
    // 设置起点的访问状态和距离
    visited[1] = 1;
    Dist[1] = 0;
    Time[1] = 0;

    // 算法主循环，找到未访问的具有最小时间的节点
    while(1) {
        int MinDistance = 0x3f3f3f; // 初始化最小距离为无穷大
        int MinTime = 0x3f3f3f; // 初始化最小时间为无穷大
        int u = -1; // 当前找到的未访问的具有最小时间的节点
        // 查找当前未访问的具有最小时间的节点
        for(int i = 1; i <= n; i++) {
            if(visited[i] != 2 && Time[i] < MinTime) {
                MinTime = Time[i];
                MinDistance = Dist[i];
                u = i;
            } else if(visited[i] != 2 && Time[i] == MinTime && MinDistance >= Dist[i]) {
                MinTime = Time[i];
                MinDistance = Dist[i];
                u = i;
            }
        }
        // 如果找不到这样的节点，则算法结束
        if(u == -1) {
            break;
        }
        // 更新访问状态和松弛操作
        visited[u] = 2;
        for(int i = 1; i < n + 1; i++) {
            if(visited[i] != 2 && G[u][i].Time != INFTY) {
                if(Time[i] > Time[u] + G[u][i].Time) {
                    Time[i] = Time[u] + G[u][i].Time;
                    Dist[i] = Dist[u] + G[u][i].dist;
                    visited[i] = 1; // 标记为已发现但不最优的节点
                    pre[i] = u; // 更新前驱节点
                }
            }
        }
    }
}

// 递归函数，用于打印从起始节点到目标节点的最短路径
void shortPathPre(int s, int v) {
    if(s == v) {
        cout << s; // 打印当前节点
        return;
    }
    shortPathPre(s, pre[v]); // 递归调用，打印路径
    cout << "->"; // 输出连接符号
    cout << v; // 打印当前节点
}

int main() {
    // 读取图中的节点数和边数以及终点节点
    int n, m, end;
    cin >> n >> m >> end;
    // 初始化图的所有边为无穷大
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= n; j++) {
            G[i][j].Time = INFTY;
            G[i][j].dist = INFTY;
        }
    }
    // 读取边的信息并更新图的邻接矩阵
    while(m--) {
        int x1, x2, time, distance;
        cin >> x1 >> x2 >> time >> distance;
        G[x1][x2].Time = time;
        G[x1][x2].dist = distance;
        G[x2][x1].Time = time; // 因为是无向图，所以双向都更新
        G[x2][x1].dist = distance;
    }
    // 初始化距离数组和时间数组
    int Dist[n + 1], Time[n + 1];
    for(int i = 1; i < n + 1; i++) {
        Dist[i] = INFTY;
        Time[i] = INFTY;
    }
    // 调用Dijkstra算法计算最短时间和最短路径
    Dijkstra(Dist, n, Time);
    // 输出结果
    cout << Time[end] << ' ' << Dist[end] << ' ';
    shortPathPre(1, end); // 打印最短路径
    return 0;
}