bzoj3669: [Noi2014]魔法森林 lct

记得去年模拟赛的时候好像YY出二分答案枚举a,b的暴力,过了55欸

然后看正解,为了将两维变成一维,将a排序,模拟Kruskal的加边过程,同时维护1到n的最大值,加入一条边e(u,v,a,b)时有以下两种情况:

1) 若u,v已连通,则找出u->v上最大的b‘,若b<b‘,则替换之,同时更新答案,注意e一定经过1->n,因为去掉b‘所在边时1,n一定不连通,若加上e后1,n连通,则必经过e,由于a是有序的,所以a是路径上最大的a,用a+MAX_b[1->n]更新答案即可。

2)否则,直接加入边e;

显然以上操作可以用lct处理。

对于维护边的信息,考虑把边看成点,与原来的真正的节点一起构成一棵(或多棵)lct,将边的信息存在对应的点上,并保证真正的结点不会对答案产生影响(相当于只起连通的作用),对于这道题,保证w[x]=0(x是结点的结点),x(x是边的结点)即可。

  1 #include<iostream>
  2 #include<cstring>
  3 #include<cstdlib>
  4 #include<algorithm>
  5 #include<cstdio>
  6
  7 using namespace std;
  8
  9 // The default source begin-----------
 10 const int MXD=~0u>>1;
 11 const int D=15000000;
 12 char in[D],out[300010*10],*I=in,*O=out;
 13 #define gc (*I++)
 14 #define pc(x) ((*O++)=x)
 15 #define tQ template <typename Q>
 16 tQ void gt(Q&x) {
 17     static char c,f;
 18     for(f=0;c=gc,!isdigit(c);)if(c==‘-‘) f=1;
 19     for(x=0;isdigit(c);c=gc) x=(x<<3) + (x<<1) +c-‘0‘;
 20     f && (x=-x);
 21 }
 22 tQ void pt(Q x){
 23     static char stk[20];
 24     static int top;
 25     top=0;
 26     if(x==0) pc(‘0‘);
 27     for(;x;x/=10) stk[++top] = x%10+‘0‘;
 28     for(;top;top--) pc(stk[top]);
 29 }
 30 // The default source end-----------
 31
 32 const int Maxn=50010,Maxm=100010;
 33 int n,m;
 34 struct Edge{
 35     int u,v,a,b;
 36     inline bool operator < (const Edge&rhs) const {
 37         return a<rhs.a || (a==rhs.a && b<rhs.b);
 38     }
 39     inline void read() {
 40         gt(u),gt(v),gt(a),gt(b);
 41     }
 42 }edges[Maxm];
 43
 44 int ch[Maxn+Maxm][2],p[Maxn+Maxm],flip[Maxn+Maxm],mx[Maxn+Maxm],w[Maxn+Maxm];
 45
 46 #define l ch[x][0]
 47 #define r ch[x][1]
 48 void update(int x){
 49     if(!x) return;
 50     mx[x]=x;
 51     if(w[mx[l]]>w[mx[x]]) mx[x]=mx[l];
 52     if(w[mx[r]]>w[mx[x]]) mx[x]=mx[r];
 53 }
 54 void down(int x) {
 55     if(!x || !flip[x]) return;
 56     swap(l,r);
 57     flip[l]^=1;
 58     flip[r]^=1;
 59     flip[x]=0;
 60 }
 61 #undef l
 62 #undef r
 63 inline bool isroot(int x) {
 64     return ch[p[x]][0]!=x && ch[p[x]][1]!=x;
 65 }
 66 inline void rotate(int x){
 67     int y=p[x],z=p[y];
 68     int l=ch[y][1]==x,r=l^1;
 69     if(!isroot(y)){
 70         ch[z][ch[z][1]==y]=x;
 71     }
 72     p[y]=x;
 73     p[ch[x][r]]=y;
 74     p[x]=z;
 75
 76     ch[y][l]=ch[x][r];
 77     ch[x][r]=y;
 78
 79     update(y);
 80 //    update(x);
 81 }
 82
 83 int stk[Maxn],top;
 84 inline void splay(int x){
 85     stk[top=1]=x;
 86     for(int t=x;!isroot(t);stk[++top]=t=p[t]);
 87     for(;top;top--) down(stk[top]);
 88     for(;!isroot(x);){
 89         int y=p[x],z=p[y];
 90         if(!isroot(y)) {
 91             if( (ch[y][0]==x) ^ (ch[z][0]==y)) rotate(x);
 92             else rotate(y);
 93         }
 94         rotate(x);
 95     }
 96     update(x);
 97 }
 98
 99 inline void access(int x) {
100     for(int t=0;x;x=p[t=x]){
101         splay(x);
102         ch[x][1]=t;
103         update(x);
104     }
105 }
106
107 inline void newroot(int x) {
108     access(x);
109     splay(x);
110     flip[x]^=1;
111 }
112
113 inline void n_as(int u,int v){
114     newroot(u);
115     access(v);
116     splay(v);
117 }
118
119 inline void Cut(int x,int y) {
120     n_as(x,y);
121     ch[y][0]=p[x]=0;
122     update(x);
123 }
124
125 inline void Link(int x,int y) {
126     newroot(x);
127     p[x]=y;
128 }
129
130 int fa[Maxn];
131 int Find(int x) {
132     return x==fa[x]?x:fa[x]=Find(fa[x]);
133 }
134
135 inline bool Union(int x,int y){
136     x=Find(x);y=Find(y);
137     if(x==y) return 0;
138     return fa[x]=y,1;
139 }
140
141 inline void ufs_init(int n) {
142     for(int i=0;i<=n;i++) fa[i]=i;
143 }
144
145 inline void init() {
146     gt(n),gt(m);
147     for(int i=1;i<=m;i++) edges[i].read();
148     ufs_init(n);
149 }
150
151 inline int getroot(int x) {
152     for(access(x),splay(x);ch[x][0];x=ch[x][0]);
153     return x;
154 }
155
156 inline void work() {
157     sort(edges+1,edges+m+1);
158     int ans=MXD;
159     for(int i=1;i<=m;i++) {
160         const Edge& e=edges[i];
161         w[i+n]=e.b;
162         if(Union(e.u,e.v)) {
163             Link(e.u,i+n);
164             Link(e.v,i+n);
165         }else {
166             n_as(e.u,e.v);
167             int t=mx[e.v];
168             if(w[t] > e.b) {
169                 Cut(edges[t-n].u,t);
170                 Cut(edges[t-n].v,t);
171                 Link(e.u,i+n);
172                 Link(e.v,i+n);
173             }
174         }
175         newroot(1);
176         if(getroot(n)==1) {
177             access(n);
178             splay(n);
179             ans = min (ans,e.a + w[mx[n]]);
180         }
181     }
182     printf("%d\n",ans==MXD?-1:ans);
183 }
184
185 int main() {
186 #ifdef DEBUG
187     freopen("forest.in","r",stdin);
188     freopen("forest.out","w",stdout);
189 #endif
190     fread(in,1,D,stdin);
191     init();
192     work();
193
194     return 0;
195 }
时间: 2024-10-17 15:46:36

bzoj3669: [Noi2014]魔法森林 lct的相关文章

bzoj3669 [Noi2014]魔法森林——LCT

题目:https://www.lydsy.com/JudgeOnline/problem.php?id=3669 第一道LCT! 主要是看这个博客理解学LCT板子:https://blog.csdn.net/yxuanwkeith/article/details/50991326 关于这道题,又看了看这个博客:https://blog.csdn.net/clove_unique/article/details/51317842 然后努力抄写了半天,成功AC! 代码中 //// 的地方是我还有点不

【BZOJ3669】[Noi2014]魔法森林 LCT

[BZOJ3669][Noi2014]魔法森林 Description 为了得到书法大家的真传,小E同学下定决心去拜访住在魔法森林中的隐士.魔法森林可以被看成一个包含个N节点M条边的无向图,节点标号为1..N,边标号为1..M.初始时小E同学在号节点1,隐士则住在号节点N.小E需要通过这一片魔法森林,才能够拜访到隐士. 魔法森林中居住了一些妖怪.每当有人经过一条边的时候,这条边上的妖怪就会对其发起攻击.幸运的是,在号节点住着两种守护精灵:A型守护精灵与B型守护精灵.小E可以借助它们的力量,达到自

BZOJ 3669: [Noi2014]魔法森林( LCT )

排序搞掉一维, 然后就用LCT维护加边MST. O(NlogN) -------------------------------------------------------------------------------------- #include<cstdio> #include<cctype> #include<cstring> #include<algorithm> using namespace std; const int maxn = 1

[bzoj3669][Noi2014]魔法森林_LCT_并查集

魔法森林 bzoj-3669 Noi-2014 题目大意:说不明白题意系列++……题目链接 注释:略. 想法:如果只有1个参量的话spfa.dij什么的都上来了. 两个参量的话我们考虑,想将所有的边按照a排序. 如果两个点:它们之间有两条路径,有一条比另一条劣. 那么我们完全可以将另一条弄掉. 排序之后维护生成树. LCT的点维护的是实子树中第二参量的最大值. 如果当前边连接的两点之前不连通,直接连上. 如果联通,我们判断新边的第二参量和两点之间splay的最大参量之间的关系. 如果新边的第二参

BZOJ3669: [Noi2014]魔法森林

传送门 高级数据结构学傻系列 正解似乎是最短路xjb搞,但是用LCT瞎搞搞也是很吼啊. 从贪心开始,按照每条边a的大小随意sort一下. 对于每个边,我们check两点的联通性,如果联通的话取b最大的值,如果大于当前边的b的话就就删除最大边,把这条边加进去. 如果不连通的话直接添加即可. LCT滋次这些操作,所以大力LCT即可. //BZOJ 3669 //by Cydiater //2017.2.16 #include <iostream> #include <queue> #i

【BZOJ 3669】 [Noi2014]魔法森林 LCT维护动态最小生成树

这道题看题意是在求一个二维最小瓶颈路,唯一可行方案就是枚举一维在这一维满足的条件下使另一维最小,那么我们就把第一维排序利用A小的边在A大的情况下仍成立来动态加边维护最小生成树. #include <cstdio> #include <algorithm> namespace Pre{ inline void read(int &sum){ register char ch=getchar(); for(sum=0;ch<'0'||ch>'9';ch=getcha

Vijos1865 NOI2014 魔法森林 LCT维护生成树

基本思路: 首先按照weightA升序排序,然后依次在图中加边,并维护起点到终点路径上weightB的最大值 如果加边过程中生成了环,则删除环中weightB最大的边 由于是无向图,点之间没有拓扑序,所以在建立LCT模型时,可以将原图的边也视为点,这样就转化成了维护路径上的点权最大值(Orz Hzwer) 点的连通性可以用并查集维护 AC code:(其实Splay双旋一次时只需要进行3次update,而代码中舍弃了这个优化) 1 #include <cstdio> 2 #include &l

沉迷Link-Cut tree无法自拔之:[BZOJ3669][Noi2014] 魔法森林

来自蒟蒻 \(Hero \_of \_Someone\) 的 \(LCT\) 学习笔记 $ $ 有一个很好的做法是 \(spfa\) ,但是我们不聊 \(spfa\) , 来聊 \(LCT\) \(LCT\) 做法跟 \(spfa\) 的做法其实有点像, 先将所有的边按 \(a\) 的值从小到大排, 再以 \(b\) 的值为边权来动态的维护最小生成树, 答案即为 当前插入边的 \(a\) 值加上最小生成树中的最大边权 的最小值 $ $ 此外, 用 \(LCT\) 维护 \(MST\) , 就是在

洛谷 2387 NOI2014魔法森林 LCT

[题解] 我们先把边按照$a$值从小到大排序,并按照这个顺序加边. 如果当前要加入的边连接的两点$u$与$v$已经是连通的,那么直接加入这条边就会出现环.这时我们需要删除这个环中$b$值最大的边.因此我们需要维护区间最大值,以及最大值的位置. 如果当前$1$与$n$已经连通,就更新$ans$,当前从$1~n$的代价是$ai+val[querymax(1,n)]$: 为了方便处理,我们可以把边开成点,即加边的时候多开一个表示这条边的点,在上面记录边权等信息. 1 #include<cstdio>