最短路 - A - Til the Cows Come Home POJ - 2387

本文介绍了一道经典的图论问题——寻找两点间的最短路径。问题背景为一头名为Bessie的奶牛需要从牧场返回谷仓,通过构建图模型并使用Dijkstra算法找到了最优路径。文中提供了一份详细的AC代码实现。

 A - Til the Cows Come Home

Bessie is out in the field and wants to get back to the barn to get as much sleep as possible before Farmer John wakes her for the morning milking. Bessie needs her beauty sleep, so she wants to get back as quickly as possible.


Farmer John's field has N (2 <= N <= 1000) landmarks in it, uniquely numbered 1..N. Landmark 1 is the barn; the apple tree grove in which Bessie stands all day is landmark N. Cows travel in the field using T (1 <= T <= 2000) bidirectional cow-trails of various lengths between the landmarks. Bessie is not confident of her navigation ability, so she always stays on a trail from its start to its end once she starts it.

Given the trails between the landmarks, determine the minimum distance Bessie must walk to get back to the barn. It is guaranteed that some such route exists.
Input
* Line 1: Two integers: T and N

* Lines 2..T+1: Each line describes a trail as three space-separated integers. The first two integers are the landmarks between which the trail travels. The third integer is the length of the trail, range 1..100.
Output
* Line 1: A single integer, the minimum distance that Bessie must travel to get from landmark N to landmark 1.
Sample Input
5 5
1 2 20
2 3 30
3 4 20
4 5 20
1 5 100
Sample Output

90

题意及题解:找最短路模板题,注意双向以及有多条路。

AC代码:

#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
const int maxn = 1005;
const int inf = 1e9;
int t,n,m;
int a[maxn][maxn];
int vis[maxn];
int length[maxn];
void intc()
{
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
    {
        if(i==j)a[i][j]=0;
        else a[i][j]=inf;
    }
}
void dis()
{
    for(int i=1;i<=n;i++)
    {
        length[i]=a[1][i];
        vis[i]=0;
    }
    for(int i=1;i<=n;i++)
    {
        int u=inf;
        int v;
        for(int j=1;j<=n;j++)
        {
            if(vis[j]==0&&length[j]<u)
            {
                u=length[j];
                v=j;
            }
        }
        vis[v]=1;
        for(int j=1;j<=n;j++)
        {
            length[j]=min(length[j],length[v]+a[v][j]);
        }

    }
           printf("%d\n",length[n]);
}
int main()
{
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        intc();
        for(int i=1;i<=m;i++)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            if(a[x][y]>z)a[x][y]=a[y][x]=z;
        }
        dis();
    }
}


### 问题解析:A - Til the Cows Come Home 此问题本质上是一个经典的**短路径问题**,要求从一个起点(编号为N的节点)到达终点(编号为1的节点)的短路径长度。题目中的节点代表地标,边代表双向的路径,且每条边具有特定的长度。由于节点数量多为1000,边数多为2000,算法的时间复杂性需要控制在合理范围内。 ### 解题思路 此问题可以使用多种短路径算法来解决,常见的包括: - **Dijkstra算法**:适用于非负权图,时间复杂度为 $O(N^2)$,若使用优先队列优化可降低到 $O(M \log N)$,非常适合本题的数据规模。 - **SPFA算法(Shortest Path Faster Algorithm)**:基于Bellman-Ford算法的优化,适用于稀疏图,平均时间复杂度为 $O(M)$,但在坏情况下为 $O(N \cdot M)$。 - **Bellman-Ford算法**:适用于存在负权边的图,但时间复杂度较高,本题中无需使用。 由于题目中所有边的权重均为正数,因此优先选择 **Dijkstra算法**。 ### 算法实现步骤 1. **构建图的邻接表或邻接矩阵**: - 使用邻接表存储每个节点的相邻节点及边的权重。 2. **初始化距离数组**: - 设置起点(节点N)的距离为0,其他节点的距离初始化为无穷大。 3. **使用优先队列优化的Dijkstra算法**: - 从起点开始,每次选择当前距离小的节点进行松弛操作。 4. **输出节点1的短距离**。 ### 示例代码(Dijkstra优先队列优化) ```cpp #include <bits/stdc++.h> using namespace std; const int MAXN = 1005; const int INF = 0x3f3f3f3f; int N, T; vector<pair<int, int>> adj[MAXN]; // 邻接表 int dist[MAXN]; // 短距离数组 bool visited[MAXN]; // 访问标记数组 void dijkstra(int start) { priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq; fill(dist, dist + N + 1, INF); dist[start] = 0; pq.push({0, start}); while (!pq.empty()) { int u = pq.top().second; int d = pq.top().first; pq.pop(); if (visited[u]) continue; visited[u] = true; for (auto &edge : adj[u]) { int v = edge.first; int w = edge.second; if (dist[v] > d + w) { dist[v] = d + w; pq.push({dist[v], v}); } } } } int main() { cin >> N >> T; for (int i = 0; i < T; ++i) { int u, v, w; cin >> u >> v >> w; adj[u].push_back({v, w}); adj[v].push_back({u, w}); // 双向边 } dijkstra(N); // 从节点N出发 cout << dist[1] << endl; // 输出到节点1的短距离 return 0; } ``` ### 说明 - 本代码使用了 `priority_queue` 实现 Dijkstra 算法的优先队列优化。 - 输入数据的处理中,由于边是双向的,因此在邻接表中分别添加了正向和反向的边。 - 终输出的是从节点N到节点1的短路径长度。 ### 复杂度分析 - **时间复杂度**:$O(M \log N)$,其中 $M$ 是边的数量,$N$ 是节点的数量。 - **空间复杂度**:$O(N + M)$,用于存储邻接表和距离数组。 该算法在本题中表现优异,完全满足时间限制要求。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值