CodeForces - 1253F Cheap Robot (多源Dijkstra+最小生成树)

题意是有一张无向连通图，边带权，每走过一条边需要消耗一定的电量。有k个关键点可以充满电，问从一个关键点走到另一个关键点，需要的电池容量至少是多少。

首先可以分析一下极端情况：

1.k=2：问题转化成求两点间最短路

2.k=n：问题转化成求最小生成树

所以要把两者综合起来考虑。

首先对所有关键点求一个多源最短路，得到每个点到最近的关键点的距离d，之后会发现：

1.假设走到某个点时的电量小于d，那么这个点就废掉了(永远不可能走到其他关键点)
2.假设电池容量为c，在不废掉的前提下，到达每个点时的电量必然是c-d(如果小于这个值，就可以走到最近的关键点充满电再走回来，前提是电量不小于d)

所以，对于每条边(u,v,w)，点u可通过这条边走到点v的条件是c-d[u]-w>=d[v]，即d[u]+d[v]+w<=c，这个性质关于u和v是对称的。(这个结论成立的前提是起点和终点都必须是关键点，否则就不可做了)

因此可以把每条边的边权改为(u,v,d[u]+d[v]+w)，用kruskal算法求个全局最小生成树(按秩合并，无路径压缩)，之后可以$O(logn)$询问。总复杂度$O(mlogm+qlogn)$

(ps：如果对最小生成树再来个树剖，这样复杂度就成了$O(mlogm+qloglogn)$，或者倍增RMQ可以做到$O(mlogm+nloglogn+q)$)

 1 #include<bits/stdc++.h>
 2 using namespace std;
 3 typedef long long ll;
 4 const int N=3e5+10,mod=1e9+7;
 5 ll inf=0x3f3f3f3f3f3f3f3f;
 6 int n,m,k,Q,fa[N],hd[N],ne,mxd[N];
 7 ll d[N],val[N];
 8 struct E {int v,c,nxt;} e[N<<1];
 9 struct E2 {
10     int u,v;
11     ll c;
12     bool operator<(const E2& b)const {return c<b.c;}
13 } e2[N];
14 void link(int u,int v,int c) {e[ne]= {v,c,hd[u]},hd[u]=ne++;}
15 struct D {
16     int u;
17     ll g;
18     bool operator<(const D& b)const {return g>b.g;}
19 };
20 void Dij() {
21     priority_queue<D> q;
22     memset(d,inf,sizeof d);
23     for(int i=1; i<=k; ++i)q.push({i,d[i]=0});
24     while(q.size()) {
25         int u=q.top().u;
26         ll g=q.top().g;
27         q.pop();
28         if(d[u]!=g)continue;
29         for(int i=hd[u]; ~i; i=e[i].nxt) {
30             int v=e[i].v,c=e[i].c;
31             if(d[v]>d[u]+c)d[v]=d[u]+c,q.push({v,d[v]});
32         }
33     }
34 }
35 int fd(int x) {return fa[x]?fd(fa[x]):x;}
36 void mg(int x,int y,ll c) {
37     int fx=fd(x),fy=fd(y);
38     if(fx==fy)return;
39     if(mxd[fx]>mxd[fy])swap(fx,fy);
40     fa[fx]=fy,val[fx]=c,mxd[fy]=max(mxd[fy],mxd[fx]+1);
41 }
42 void Kruskal() {
43     sort(e2,e2+m);
44     for(int i=1; i<=n; ++i)mxd[i]=1,fa[i]=0;
45     for(int i=0; i<m; ++i) {
46         int u=e2[i].u,v=e2[i].v;
47         ll c=e2[i].c;
48         mg(u,v,c);
49     }
50 }
51 ll qry(int u,int v) {
52     ll ret=0;
53     for(; u!=v; u=fa[u]) {
54         if(mxd[u]>mxd[v])swap(u,v);
55         ret=max(ret,val[u]);
56     }
57     return ret;
58 }
59 int main() {
60     memset(hd,-1,sizeof hd),ne=0;
61     scanf("%d%d%d%d",&n,&m,&k,&Q);
62     for(int i=0; i<m; ++i) {
63         int u,v,c;
64         scanf("%d%d%d",&u,&v,&c);
65         link(u,v,c);
66         link(v,u,c);
67         e2[i]= {u,v,c};
68     }
69     Dij();
70     for(int i=0; i<m; ++i)e2[i].c+=d[e2[i].u]+d[e2[i].v];
71     Kruskal();
72     while(Q--) {
73         int u,v;
74         scanf("%d%d",&u,&v);
75         printf("%lld\n",qry(u,v));
76     }
77     return 0;
78 }

标签：int,fy,ll,Cheap,CodeForces,Robot,fx,mxd,关键点
来源： https://www.cnblogs.com/asdfsag/p/12418911.html