计蒜客 Charles in Charge（ACM ICPC 2017 Warmup Contest 9)

题目：https://nanti.jisuanke.com/t/17954

样例输入1

2 1 100
1 2 5
样例输出1

5
样例输入2

9 8 15
1 9 16
1 4 4
4 5 4
5 6 4
6 8 4
4 7 5
7 8 5
8 9 4
样例输出2

5

题意：给定 n个点m条边，和数x ，设1->n的最短路为 d, 求一条 1->n 的路径 使得路径上的最大的边的长度最短 且 路径长度 L<= d*(1+x)  。输出最大边权值。

分析：二分最大边的长度 ， 然后 求最短路 看是否满足条件就行了。

#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<queue>
#include<vector>
const int maxn = 100000;
const long long int inf = 99999999999999999;
typedef long long ll;
using namespace std;
struct HeapNode
{
    ll d;
    int u;
    bool operator < (const HeapNode &rhs) const
    {
        return d > rhs.d;
    }
};
struct Edge
{
    int fr,to,dist;
};
struct Dijkstra
{
    int n,m;
    vector<Edge>edges;
    vector<int>G[maxn+5];
    bool done[maxn+5];
    ll d[maxn+5];
    int p[maxn+5];

    void init(int n)
    {
        this->n = n;
        for(int i=0; i<=n; i++) G[i].clear();
        edges.clear();
    }

    void addedge(int fr,int to,int dist)
    {
        edges.push_back((Edge)
        {
            fr,to,dist
        });
        m = edges.size();
        G[fr].push_back(m-1);
    }

    void dijkstra(int s,int Me)
    {
        priority_queue<HeapNode>Q;
        for(int i=0; i<=n; i++) d[i] = inf;
        d[s] = 0;
        memset(done,0,sizeof(done));
        Q.push((HeapNode)
        {
            0,s
        });
        while(!Q.empty())
        {
            HeapNode x = Q.top();
            Q.pop();
            int u = x.u;
            if(done[u]) continue;
            done[u] = true;
            for(int i=0,l=G[u].size(); i<l; i++)
            {
                Edge& e = edges[G[u][i]];
                if(e.dist>Me) continue;// 当边大于最大边的长度时不走。
                if(d[e.to]>d[u]+e.dist*1ll)
                {
                    d[e.to] = d[u] + e.dist*1ll;
                    p[e.to] = G[u][i];
                    Q.push((HeapNode)
                    {
                        d[e.to],e.to
                    });
                }
            }
        }
    }

} my;
int n,m,X;
ll Max;
int main()
{
    int L,R,mid;
    while(~scanf("%d %d %d",&n,&m,&X))
    {
        my.init(n);
        L = 0, R = 0;
        for(int i=1; i<=m; i++)
        {
            int x,y,w;
            scanf("%d %d %d",&x,&y,&w);
            my.addedge(x,y,w);
            my.addedge(y,x,w);
            R = max(R,w);
        }
        my.dijkstra(1,R+100);
        Max = (1.0+X*1.0/100.0)*(my.d[n]*1.0);

        while(R-L>1)//二分最大边的长度
        {
            mid = (L+R)>>1;
            my.dijkstra(1,mid);
            ll tmp = my.d[n];
            if(tmp<=Max) R = mid;
            else L = mid;
        }
        printf("%d\n",R);
    }
    return 0;
}