Heavy Transportation dijkstra(附vector模拟邻接表)

Heavy Transportation
Time Limit: 3000MS Memory Limit: 30000K
Total Submissions: 37741 Accepted: 9944

Description
Background
Hugo Heavy is happy. After the breakdown of the Cargolifter project he can now expand business. But he needs a clever man who tells him whether there really is a way from the place his customer has build his giant steel crane to the place where it is needed on which all streets can carry the weight.
Fortunately he already has a plan of the city with all streets and bridges and all the allowed weights.Unfortunately he has no idea how to find the the maximum weight capacity in order to tell his customer how heavy the crane may become. But you surely know.

Problem
You are given the plan of the city, described by the streets (with weight limits) between the crossings, which are numbered from 1 to n. Your task is to find the maximum weight that can be transported from crossing 1 (Hugo’s place) to crossing n (the customer’s place). You may assume that there is at least one path. All streets can be travelled in both directions.

Input
The first line contains the number of scenarios (city plans). For each city the number n of street crossings (1 <= n <= 1000) and number m of streets are given on the first line. The following m lines contain triples of integers specifying start and end crossing of the street and the maximum allowed weight, which is positive and not larger than 1000000. There will be at most one street between each pair of crossings.

Output
The output for every scenario begins with a line containing “Scenario #i:”, where i is the number of the scenario starting at 1. Then print a single line containing the maximum allowed weight that Hugo can transport to the customer. Terminate the output for the scenario with a blank line.

Sample Input

1
3 3
1 2 3
1 3 4
2 3 5

Sample Output

Scenario #1:
4

题意:看示例也可知 从1到n可以有很多条路,而每条路线都有一个最大载重量(由该路线中载重最小的路决定)。输出载重最大的路线的载重量。
dijkstra的变形。
1.

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <queue>
#include <cmath>
#define inf 0x3f3f3f
using namespace std;
int ma[1005][1005];
int book[1005];
int dis[1005];
int main()
{
    int i, j, T;
    int n, m,cnt=0;
    cin>>T;
    for(int o=1;o<=T;o++)
    {
        cin>>n>>m;
        memset(ma,0,sizeof(ma));//因为这句话WA了一下午。。。
        for(i=0; i<m; i++)//   写成了sizeof(0)... 建议以后直接define
        {
            int x, y, z;
            scanf("%d%d%d",&x,&y,&z);
            ma[x][y] = z;
            ma[y][x] = z;
        }
        for(i=1; i<=n; i++)
        {
            dis[i] = ma[1][i];
            book[i] = 0;
        }
        int mi,t;
        for(i=1; i<n; i++)
        {
            mi = 0;
            for(int j=1; j<=n; j++)
            {
                if(!book[j] && mi<dis[j])
                {
                    mi = dis[t = j];//  get新写法
                }
            }
            book[t] = 1;
            for(int j=1; j<=n; j++)
            {
                if(dis[j]<min(dis[t],ma[t][j]))//这个“松弛”是找另一个载重量更大的
                    dis[j] = min(dis[t],ma[t][j]);
            }
        }
        printf("Scenario #%d:\n",o);
        printf("%d\n\n",dis[n]);
    }
    return 0;
}

2.vector模拟邻接表

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <queue>
#include <cmath>
#define inf 0x3f3f3f
#define ms(x) memset(x,0,sizeof(x));
using namespace std;
int book[1005];
int dis[1005];
struct node
{
    int v, w;
};
vector<node>e[1005];
int main()
{
    int i, j, T;
    int n, m;
    cin>>T;
    for(int o=1;o<=T;o++)
    {
        cin>>n>>m;
        for(i=1;i<=n;i++)
            e[i].clear();
        for(i=0; i<m; i++)
        {
            int x, y, z;
            scanf("%d%d%d",&x,&y,&z);
            e[x].push_back((node){y,z});
            e[y].push_back((node){x,z});
        }
        for(i=1; i<=n; i++)
        {
            book[i] = 0;
        }
        int mi,u;
        ms(dis);
        dis[1] = inf;
        for(i=1; i<n; i++)
        {
            mi = 0;
            for(int j=1; j<=n; j++)
            {
                if(!book[j] && dis[j] > mi)
                {
                    mi = dis[u = j];
                }
            }
            book[u] = 1;
            for(int j=0; j<(int)e[u].size(); j++)
            {
                dis[e[u][j].v] = max(dis[e[u][j].v], min(dis[u], e[u][j].w));
            }
        }
        printf("Scenario #%d:\n",o);
        printf("%d\n\n",dis[n]);
    }
    return 0;
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Dijkstra 算法是一种用于计算图中最短路径的算法,可以用邻接表来实现。下面是一个使用邻接表实现 Dijkstra 算法的示例代码: ```python import heapq def dijkstra(adj, start): # 初始化距离数组 dist = [float('inf')] * len(adj) dist[start] = 0 # 使用堆来存储未处理的节点 heap = [(0, start)] while heap: d, u = heapq.heappop(heap) if d > dist[u]: continue for v, w in adj[u]: if dist[u] + w < dist[v]: dist[v] = dist[u] + w heapq.heappush(heap, (dist[v], v)) return dist ``` 在这个实现中,我们使用了 Python 中的 heapq 库来实现堆。首先,我们初始化一个距离数组,将起点的距离设置为 0,其余节点的距离设置为无穷大。然后,我们将起点加入堆中。接下来,我们不断地从堆中取出距离最小的节点,并更新与之相邻的节点的距离。如果更新后的距离比原来的距离更小,我们就将它加入堆中。最后,我们返回距离数组。 在邻接表中,每个节点对应一个列表,其中包含该节点连向的所有节点及其权重。在示例代码中,我们将邻接表存储为一个列表,其中每个元素是一个包含节点和其邻居的列表。例如,如果节点 0 连向节点 1 和节点 2,权重分别为 2 和 5,则邻接表中的第一个元素为 [(1, 2), (2, 5)]。 注意,由于 Dijkstra 算法中使用了堆来实现优先队列,因此时间复杂度为 O((E+V)logV),其中 E 表示边数,V 表示节点数。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值