【5.13test】SJR 的金字塔_打开.sjr文件-CSDN博客

本文链接：https://blog.csdn.net/sdfzchy/article/details/71909285

SJR 的金字塔 (pyramid)

问题描述
有一群机房小伙伴潜入SJR 的金字塔盗宝。当他们打开一个宝箱的时候，突然冒出一阵烟（潘多拉的盒子？），他们迅速意识到形势不妙，三十六计走为上计…… 由于他们盗得了金字塔的地图，所以他们希望能找出最佳逃跑路线。地图上标有 N 个室，她现在就在 1 室，金字塔的出口在N 室。他们知道一个秘密：那阵烟会让她在直接连接某两个室之间的通道内的行走速度减半。他们希望找出一条逃跑路线，使得在最坏的情况下所用的时间最少。

输入文件

输入文件第一行有两个正整数N 和M ， 
下面有M 行，每行有三个正整数U、V、W，表示直接从U 室跑到V 室（或者从V 室跑到U 室）需要W 秒。

输出文件
输出文件只包含一行，一个数，为所求的最少时间（单位为秒）。

样例输入
7 8
1 2 10
2 3 12
3 4 20
4 7 8
1 7 34
2 5 10
5 6 12
6 4 13

样例输出
66

样例说明：
基本上有三种路线：
一：1 -> 2 -> 3 -> 4 -> 7 总时间为 10 + 12 + 20 + 8 = 50，最坏的情况是 3->4 那一段，要多花20 秒（因为行走速度减半），所以这条路选最坏需要 70 秒
二：1 -> 2 -> 5 -> 6 -> 4 -> 7 总时间为 10 + 10 + 12 + 13 + 8 = 53，最坏的情况是 6->4 那一段，要多花13 秒（因为行走速度减半），所以这条路选最坏需要 66 秒
三：1 -> 7 总时间为 34 = 34，最坏的情况是 1->7 那一段，要多花34
秒（因为行走速度减半），所以这条路选最坏需要 68 秒。
数据范围
对于30%的数据，N≤20。
对于60%的数据，N≤60，M≤1000。
对于100%的数据，3≤N≤100，3≤M≤2000，3≤W≤255。

题意：n个点m条边，求出一条1到n的路径，使路径长度+路径上最长边的和最小

很水的一道图论题（exm？！确定很水吗？？）
SPFA稍微变一变就好了
给出两种思路

题解：
1.输入边的时候记录每一条边，然后按照边大小进行排序，从小到大枚举每一条边，算出以这条边（limit）为最大边的最短路径（可以二分求解），用limit+最短路长度更新ans

#include<iostream>
#include<cstdio>
#include<cstring>
#include<ctime>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<queue>
#include<set>
#include<map>
#include<vector>
#include<deque>
#include<list>
#include<functional>
#include<iomanip>
#include<stack>
#include<string>
#include<bitset>
using namespace std;
#define gc ch=getchar()
#define oo (ch>='0'&&ch<='9')
char ch;bool fl;
template<class T> inline void read(T &a){
    a=fl=0;gc;
    while(!oo){if(ch=='-')fl=1;gc;}
    while oo{
        a=a*10+ch-'0';
        gc;
    }
    if(fl)a=-a;
}
#define N 110
#define M 2010
int n,m,tot,head[N],w[M],Ans=1e7;
struct Edge{
    int v,w,next;
}edge[M*2];
void addedge(int u,int v,int w){
    edge[++tot]=(Edge){v,w,head[u]};
    head[u]=tot;
}
int Dis[N];bool InQ[N];
queue<int> q;
int SPFA(int Limit){
    while(!q.empty())q.pop();
    memset(Dis,0x5f,sizeof(Dis));
    memset(InQ,0,sizeof(InQ));
    q.push(1);Dis[1]=0;InQ[1]=1;
    while(!q.empty()){
        int u=q.front();q.pop();
        InQ[u]=0;
        for(int i=head[u];i;i=edge[i].next){
            int v=edge[i].v;
            if(edge[i].w>Limit)continue;
            if(Dis[v]>Dis[u]+edge[i].w){
                Dis[v]=Dis[u]+edge[i].w;
                if(!InQ[v]){
                    InQ[v]=1;
                    q.push(v);
                }
            }
        }
    }
    return Dis[n];
}
int main(){
    freopen("pyramid.in","r",stdin);
    freopen("pyramid.out","w",stdout);
    read(n);read(m);
    for(int i=1,u,v;i<=m;++i){
        read(u);read(v);read(w[i]);
        addedge(u,v,w[i]);addedge(v,u,w[i]);
    }
    sort(w+1,w+m+1);
    for(int i=1;i<=m;++i)Ans=min(Ans,SPFA(w[i])+w[i]);
    cout<<Ans;
    return 0;
}

2.本人的思路:
只进行一次SPFA，在计算最短路的同时用big数组记录当前最短路上的边的长度的最大值，每次如果可以松弛（注意注意判断条件就OK），则更新big数组（比较神奇）

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
int head[4001],big[4001],ecnt;
queue<int> q;
struct node
{
    int next,to,dis;
}a[4001];
int dis[4001],vis[4001];
void add_edge(int from,int to,int dis)
{
    a[++ecnt].next=head[from];
    a[ecnt].to=to;
    a[ecnt].dis=dis;
    head[from]=ecnt;
}
int main()
{
    freopen("pyramid.in","r",stdin);
    freopen("pyramid.out","w",stdout);
    int n,m,u,v,w;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&u,&v,&w);
        add_edge(u,v,w);    
        add_edge(v,u,w);
    }
    memset(dis,0x3f,sizeof(dis));
    dis[1]=0;
    big[1]=0;
    q.push(1);
    vis[1]=1;
    while(!q.empty())
    {
        int t=q.front();
        vis[t]=0;
        q.pop();
        for(int i=head[t];i;i=a[i].next)
        {
            int et=a[i].to;
            int d=a[i].dis;
            if(dis[t]+d+max(d,big[t])<dis[et]+big[et])
            {
                dis[et]=dis[t]+d;
                big[et]=max(big[t],d);
                if(!vis[et]) q.push(et),vis[et]=1;
            }
        }
    }
    printf("%d",dis[n]+big[n]);
}