P1462 通往奥格瑞玛的道路

提交 29.89k

通过 6.88k

时间限制 1.00s

内存限制 125.00MB

题目提供者gconeice

难度提高+/省选-

历史分数100

提交记录

查看题解

题目背景

在艾泽拉斯大陆上有一位名叫歪嘴哦的神奇术士，他是部落的中坚力量

有一天他醒来后发现自己居然到了联盟的主城暴风城

在被众多联盟的士兵攻击后，他决定逃回自己的家乡奥格瑞玛

题目描述

在艾泽拉斯，有n个城市。编号为1,2,3,...,n。

城市之间有m条双向的公路，连接着两个城市，从某个城市到另一个城市，会遭到联盟的攻击，进而损失一定的血量。

每次经过一个城市，都会被收取一定的过路费（包括起点和终点）。路上并没有收费站。

假设1为暴风城，n为奥格瑞玛，而他的血量最多为b，出发时他的血量是满的。

歪嘴哦不希望花很多钱，他想知道，在可以到达奥格瑞玛的情况下，他所经过的所有城市中最多的一次收取的费用的最小值是多少。

输入格式

第一行3个正整数，n，m，b。分别表示有n个城市，m条公路，歪嘴哦的血量为b。

接下来有n行，每行1个正整数，fi。表示经过城市i，需要交费fi元。

再接下来有m行，每行3个正整数，ai，bi，ci(1<=ai，bi<=n)。表示城市ai和城市bi之间有一条公路，如果从城市ai到城市bi，或者从城市bi到城市ai，会损失ci的血量。

输出格式

仅一个整数，表示歪嘴哦交费最多的一次的最小值。

如果他无法到达奥格瑞玛，输出AFK。

输入输出样例

输入 #1

输出 #1

说明/提示

对于60%的数据，满足n≤200，m≤10000，b≤200

对于100%的数据，满足n≤10000，m≤50000，b≤1000000000

对于100%的数据，满足ci≤1000000000，fi≤1000000000，可能有两条边连接着相同的城市。

题意：找到一条从 1 到 n 的路，且满足路上在某个点交过路费的最大值要最小。

思路

　　因为血量有限而钱无限，所以显然我们是要找一条能活着走完的路，并且还要满足要求。

　　所有类似于“求解所有的最大值中的最小值”的问题，并且满足单调，都可以想到二分法。

　　把扣血量看作边长，在dijkstra的过程中，对于更新dis时，需要再添加一个限制条件 f [i] <= mid 来逐渐放宽我们可以走的点的范围，以此来保证一定可以走出一条血不会被扣完且收费的最大值最小的一条路。

ＣＯＤＥ

 #include <bits/stdc++.h>

 #define dbg(x) cout << #x << "=" << x << endl

 #define eps 1e-8

 #define pi acos(-1.0)

 using namespace std;

 typedef long long LL;

 template<class T>inline void read(T &res)

 {

     char c;T flag=;

     while((c=getchar())<''||c>'')if(c=='-')flag=-;res=c-'';

     while((c=getchar())>=''&&c<='')res=res*+c-'';res*=flag;

 }

 namespace _buff {

     const size_t BUFF =  << ;

     char ibuf[BUFF], *ib = ibuf, *ie = ibuf;

     char getc() {

         if (ib == ie) {

             ib = ibuf;

             ie = ibuf + fread(ibuf, , BUFF, stdin);

         }

         return ib == ie ? - : *ib++;

     }

 }

 int qread() {

     using namespace _buff;

     int ret = ;

     bool pos = true;

     char c = getc();

     for (; (c < '' || c > '') && c != '-'; c = getc()) {

         assert(~c);

     }

     if (c == '-') {

         pos = false;

         c = getc();

     }

     for (; c >= '' && c <= ''; c = getc()) {

         ret = (ret << ) + (ret << ) + (c ^ );

     }

     return pos ? ret : -ret;

 }

 const int maxn = 1e5 + ;

 const int inf  = 0x3f3f3f3f;

 int head[maxn << ], edge[maxn << ], w[maxn << ], nxt[maxn << ];

 int cnt, b;

 int f[maxn << ];

 inline void BuildGraph (int u, int v, int c) {

     cnt++;

     edge[cnt] = v;

     nxt[cnt]  = head[u];

     w[cnt] = c;

     head[u] = cnt;

 }

 struct node {

     int u,v;

     bool operator <(const node &t) const {

         return u > t.u;

     }

 };

 int n,m,s,t,maxx;

 int dis[maxn];

 priority_queue < node > q;

 bool check(int x) {

     if(x < f[])

         return ;

     for (int i = ; i <= n; ++i) {

         dis[i] = inf;

     }

     dis[] = ;

     node temp;

     temp.u = ;

     temp.v = ;

     q.push(temp);

     while(!q.empty()) {

         int u = q.top().v;

         int d = q.top().u;

         q.pop();

         if(d != dis[u]) continue;

         for (int i = head[u]; i; i = nxt[i]) {

             int v = edge[i];

             int c = w[i];

             if(dis[v] > dis[u] + c && f[v] <= x) {

                 dis[v] = dis[u] + c;

                 node p;

                 p.u = dis[v], p.v = v;

                 q.push(p);

             }

         }

     }

     if(dis[n] < b) {

         return ;

     }

     return ;

 }

 int main()

 {

     scanf("%d %d %d",&n,&m,&b);

     for (int i = ; i <= n; ++i) {

         scanf("%d",&f[i]);

         maxx = max(maxx, f[i]);

     }

     for (int i = ; i <= m; i++) {

         int u, v, c;

         scanf("%d %d %d",&u,&v,&c);

         BuildGraph(u, v, c);

         BuildGraph(v, u, c);

     }

     if(!check(inf)) {

         puts("AFK");

         return ;

     }

     int l = , r = inf, mid = (l + r) >> ;

     while(l <= r) {

         if(check(mid)) {

             r = mid - ;

             mid = (l + r) >> ;

         }

         else {

             l = mid + ;

             mid = (l + r) >> ;

         }

     }

     printf("%d\n",l);

     return ;

 }

奥格瑞玛