【bzoj2594】[Wc2006]水管局长数据加强版

真是神题

当时调了几天没调出来 后来没管了

当时把fread去掉就TLE,加上就RE

一直在底下跟网上的程序拍,尝试各种优化常数都没用

拍出几组不一样的,发现我是对的,醉了,网上那个是怎么过的

记一下这蛋疼的代码

  1 #include<iostream>
  2 #include<cstring>
  3 #include<cstdlib>
  4 #include<algorithm>
  5 #include<cstdio>
  6 #include<map>
  7
  8 using namespace std;
  9
 10 //default source begin==========
 11 const int D=30000000;
 12 char in[D],out[300010*10],*I=in+D,*O=out;
 13
 14 char gc() {
 15     if(I==in+D) fread(in,1,D,stdin),I=in;
 16     return *(I++);
 17 }
 18 #define gc gc()
 19 #define pc(x) ((*O++)=x)
 20 #define tQ template <typename Q>
 21 tQ void gt(Q&x) {
 22     static char c,f;
 23     for(f=0;c=gc,!isdigit(c);)if(c==‘-‘) f=1;
 24     for(x=0;isdigit(c);c=gc) x=x*10+c-‘0‘;
 25     f && (x=-x);
 26 }
 27 tQ void pt(Q x){
 28     static char stk[20];
 29     static int top;
 30     top=0;
 31     if(x==0) pc(‘0‘);
 32     for(;x;x/=10) stk[++top] = x%10+‘0‘;
 33     for(;top;top--) pc(stk[top]);
 34 }
 35 //default source end=============
 36
 37 const int Maxn=100100,Maxm=1000010,Maxq=100010;
 38 int n,m,Q;
 39
 40 int ch[Maxn+Maxm][2],p[Maxn+Maxm],flip[Maxn+Maxm],mx[Maxn+Maxm],w[Maxn+Maxm];
 41 map<pair<int,int> ,struct Edge*> hash;
 42 int ddb[Maxn+Maxm];
 43 typedef long long ll;
 44 /*
 45 const unsigned int Hmod=1e6+7;
 46 struct Node{
 47     ll hs;
 48     int id;
 49     Node*next;
 50     Node(ll hs=0,int id=0,Node*next=0):hs(hs),id(id),next(next){}
 51 }da[Maxm],*fir[Hmod];
 52
 53 int find(ll x){
 54     unsigned md=x%Hmod;
 55     for(Node*p=fir[md];p;p=p->next){
 56         if(p->hs==x) return p->id;
 57     }
 58     return NULL;
 59 }
 60
 61 int insert(ll x){
 62     unsigned md=x%Hmod;
 63 */
 64
 65 #define l ch[x][0]
 66 #define r ch[x][1]
 67 void update(int x){
 68     if(!x) return;
 69     mx[x]=x;
 70     if(w[mx[l]]>w[mx[x]]) mx[x]=mx[l];
 71     if(w[mx[r]]>w[mx[x]]) mx[x]=mx[r];
 72 }
 73 void down(int x) {
 74     if(!x || !flip[x]) return;
 75     swap(l,r);
 76     flip[l]^=1;
 77     flip[r]^=1;
 78     flip[x]=0;
 79 }
 80 #undef l
 81 #undef r
 82 inline bool isroot(int x) {
 83     return ch[p[x]][0]!=x && ch[p[x]][1]!=x;
 84 }
 85 inline void rotate(int x){
 86     int y=p[x],z=p[y];
 87     int l=ch[y][1]==x,r=l^1;
 88     if(!isroot(y)){
 89         ch[z][ch[z][1]==y]=x;
 90     }
 91     p[y]=x;
 92     p[ch[x][r]]=y;
 93     p[x]=z;
 94
 95     ch[y][l]=ch[x][r];
 96     ch[x][r]=y;
 97
 98     update(y);
 99 //    update(x);
100 }
101
102 int stk[Maxn],top;
103 inline void splay(int x){
104     stk[top=1]=x;
105     for(int t=x;!isroot(t);stk[++top]=t=p[t]);
106     for(;top;top--) down(stk[top]);
107     for(;!isroot(x);){
108         int y=p[x],z=p[y];
109         if(!isroot(y)) {
110             if( (ch[y][0]==x) ^ (ch[z][0]==y)) rotate(x);
111             else rotate(y);
112         }
113         rotate(x);
114     }
115     update(x);
116 }
117
118 inline void access(int x) {
119     for(int t=0;x;x=p[t=x]){
120         splay(x);
121         ch[x][1]=t;
122         update(x);
123     }
124 }
125
126 inline void newroot(int x) {
127     access(x);
128     splay(x);
129     flip[x]^=1;
130 }
131
132 inline void n_as(int u,int v){
133     newroot(u);
134     access(v);
135     splay(v);
136 }
137
138 inline void Cut(int x,int y) {
139     n_as(x,y);
140     ch[y][0]=p[x]=0;
141     update(x);
142 }
143
144 inline void Link(int x,int y) {
145     newroot(x);
146     p[x]=y;
147 }
148
149 struct Edge{
150     int u,v,w,id;
151     bool deled;
152     void read() {
153         gt(u);gt(v);gt(w);
154         if(u>v) swap(u,v);
155     }
156     bool operator<(const Edge&rhs)const {
157         return u<rhs.u || (u==rhs.u&&v<rhs.v);
158     }
159     bool operator == (const Edge&rhs)const {
160         return u==rhs.u && v==rhs.v;
161     }
162     bool operator <= (const Edge&rhs)const {
163         return *this<rhs || *this==rhs;
164     }
165     Edge(int u=0,int v=0):u(u),v(v){}
166 }e[Maxm];
167
168 bool cmpw(const Edge&lhs,const Edge&rhs) {
169     return lhs.w<rhs.w;
170 }
171
172 struct Que{
173     int k,u,v;
174     Que (int k=0,int u=0,int v=0):k(k),u(u),v(v){}
175 }que[Maxq];
176
177 int bs(const Edge&target) {
178     int l=1,r=m,res=-1;
179     for(int mid;l<=r;) {
180         mid=(l+r)>>1;
181         if(e[mid]<=target) res=mid,l=mid+1;
182         else r=mid-1;
183     }
184     if(res==-1) exit(-1);
185     return res;
186 }
187
188 int fa[Maxn];
189 int Find(int x){
190     return fa[x]==x?x:fa[x]=Find(fa[x]);
191 }
192 bool Union(int x,int y) {
193     x=Find(x),y=Find(y);
194     if(x==y) return 0;
195     return fa[x]=y,1;
196 }
197 void ufs_init(int n) {
198     for(int i=0;i<=n;i++) fa[i]=i;
199 }
200 void AddEdge(int i) {
201     const int&u=e[i].u,&v=e[i].v;
202     if(Union(u,v)) Link(u,i+n),Link(v,i+n);
203     else {
204         n_as(u,v);int t=mx[v];
205         if(w[t] > e[i].w) {
206 //            Cut(e[t-n].u,t);
207             Cut(e[t-n].v,t);
208             Link(u,i+n);
209             Link(v,i+n);
210         }
211     }
212 }
213
214 bool cmpid(const Edge&lhs,const Edge&rhs){
215     return lhs.id<rhs.id;
216 }
217
218 void init() {
219     gt(n),gt(m),gt(Q);
220     for(int i=1;i<=m;i++) e[i].read();
221     sort(e+1,e+m+1);
222     for(int i=1;i<=m;i++) e[i].id=i,w[i+n]=e[i].w;
223     for(int k,u,v,i=1;i<=Q;i++) {
224         gt(k),gt(u),gt(v);
225         if(u>v) swap(u,v);
226         que[i]=Que(k,u,v);
227         if(k==2) e[bs(Edge(u,v))].deled=1;
228     }
229 }
230
231 void Kruskal() {
232     sort(e+1,e+m+1,cmpw);
233     ufs_init(n);
234     for(int i=1,MST=0;i<=m;i++) {
235         if(e[i].deled) continue;
236         if(!Union(e[i].u,e[i].v)) continue;
237         Link(e[i].u,e[i].id+n);
238         Link(e[i].v,e[i].id+n);
239         if(++MST==n-1) break;
240     }
241 }
242
243 int ans[Maxq],tq=0;
244 void work() {
245     Kruskal();
246     sort(e+1,e+m+1);
247     for(int i=Q;i;i--) {
248         const Que&q=que[i];
249         if(q.k==1) {
250             n_as(q.u,q.v);
251             ans[++tq] = w[mx[q.v]];
252         }else {
253             AddEdge(bs(Edge(q.u,q.v)));
254         }
255     }
256     for(int i=tq;i;i--) pt(ans[i]),pc(‘\n‘);
257 }
258
259 int main() {
260 #ifdef DEBUG
261     freopen("in.txt","r",stdin);
262     freopen("out.txt","w",stdout);
263 #endif
264
265     init();
266     work();
267
268     return printf(out),0;
269 }

时间: 2024-10-05 04:58:49

【bzoj2594】[Wc2006]水管局长数据加强版的相关文章

[bzoj2594][Wc2006]水管局长数据加强版

论蒟蒻的自我修养T_T.. 和noi2014魔法森林基本一样...然而数据范围大得sxbk...100w你告诉我(n+m)log(n+m)可过?[掀桌] 蒟蒻又蠢了..复杂度应该是O((n+q)log(n+m))吧.. 一开始数组开太小re了两发(要开到maxn+maxm),然后又开太大mle一发,然后无限tle...把记录类型全改成数组还是tle.... 最后把非lct部分改得和黄学长全部一样终于20+s卡过去了......... 然后发现自己原来是有个地方写萎了..一开始把没被删的边做kru

[BZOJ2594] [Wc2006]水管局长数据加强版(LCT + kruskal + 离线)

传送门 WC这个题真是丧心病狂啊,就是想学习一下怎么处理边权,给我来了这么一个破题! ORZ hzwer 临摹黄学长代码233 但还是复杂的一匹 理一下思路吧 题目大意:给定一个无向图,多次删除图中的某一条边,求两点间路径最大值的最小值 求两点间的路径最大值的最小值的话,可以求最小生成树,那么这个值就是最小生成树上两点间路径上的最大值 但是题目要求是删除边,LCT维护最小生成树不支持删边操作,那么就离线处理,倒着加边,用LCT维护. 就是这个离线处理是最恶心的. 来说说如何处理边权,把边也抽象成

沉迷Link-Cut tree无法自拔之:[BZOJ2594][Wc2006]水管局长数据加强版

来自蒟蒻 \(Hero \_of \_Someone\) 的 \(LCT\) 学习笔记 $ $ 这应该算是道套路题吧, 如果将图中的边转换成点, 再将边权变点权, 就可以用 \(LCT\) 来维护了 这道题的基本做法就是, 用 \(LCT\) 来动态地维护最小生成树, 如果这样做的话, 题目中要求的删边操作就不太好搞, 但是既然只有删边操作的话, 我们就可以考虑离线处理, 将不会被删除的边先加进图中跑 \(Kruskal\) , 然后化删边为添边, 倒着来处理每一组询问. $ $ 此外, 用 \

bzoj 2594: [Wc2006]水管局长数据加强版 动态树

2594: [Wc2006]水管局长数据加强版 Time Limit: 25 Sec  Memory Limit: 128 MBSubmit: 934  Solved: 291[Submit][Status] Description SC省MY市有着庞大的地下水管网络,嘟嘟是MY市的水管局长(就是管水管的啦),嘟嘟作为水管局长的工作就是:每天供水公司可能要将一定量的水从x处送往y处,嘟嘟需要为供水公司找到一条从A至B的水管的路径,接着通过信息化的控制中心通知路径上的水管进入准备送水状态,等到路径

【BZOJ 2594】 [Wc2006]水管局长数据加强版

2594: [Wc2006]水管局长数据加强版 Time Limit: 25 Sec  Memory Limit: 128 MB Submit: 1138  Solved: 364 [Submit][Status] Description SC省MY市有着庞大的地下水管网络,嘟嘟是MY市的水管局长(就是管水管的啦),嘟嘟作为水管局长的工作就是:每天供水公司可能要将一定量的水从x处送往y处,嘟嘟需要为供水公司找到一条从A至B的水管的路径,接着通过信息化的控制中心通知路径上的水管进入准备送水状态,等

BZOJ_2594_[Wc2006]水管局长数据加强版_LCT

Description SC省MY市有着庞大的地下水管网络,嘟嘟是MY市的水管局长(就是管水管的啦),嘟嘟作为水管局长的工作就是:每天供水公司可能要将一定量的水从x处送往y处,嘟嘟需要为供水公司找到一条从A至B的水管的路径,接着通过信息化的控制中心通知路径上的水管进入准备送水状态,等到路径上每一条水管都准备好了,供水公司就可以开始送水了.嘟嘟一次只能处理一项送水任务,等到当前的送水任务完成了,才能处理下一项. 在处理每项送水任务之前,路径上的水管都要进行一系列的准备操作,如清洗.消毒等等.嘟嘟在

BZOJ 2594: [Wc2006]水管局长数据加强版(kruskal + LCT)

Description SC省MY市有着庞大的地下水管网络,嘟嘟是MY市的水管局长(就是管水管的啦),嘟嘟作为水管局长的工作就是:每天供水公司可能要将一定量的水从x处送往y处,嘟嘟需要为供水公司找到一条从A至B的水管的路径,接着通过信息化的控制中心通知路径上的水管进入准备送水状态,等到路径上每一条水管都准备好了,供水公司就可以开始送水了.嘟嘟一次只能处理一项送水任务,等到当前的送水任务完成了,才能处理下一项. 在处理每项送水任务之前,路径上的水管都要进行一系列的准备操作,如清洗.消毒等等.嘟嘟在

BZOJ 2594 Wc2006 水管局长数据加强版 Link-Cut-Tree

题目大意:给定一个无向图,多次删除某条边,多次查询两点之间路径上边权最大值的最小值 Link-Cut-Tree维护动态最小生成树 首先倒着做 将所有被删除的边标记(找边我用的排序+二分) 将没标记的边跑一遍Kruskal 求出最小生成树 然后每次加边和查询正常维护即可 LInk-Cut-Tree一气呵成写完,Kruskal尼玛写挂了-- 居然忘记把并查集连边 这我也是醉了 顺便吐槽一下题干上给的读入优化真尼玛弱--自己随便写一个都可以优化到RANK前十-- #include<cstdio> #

BZOJ 2594 [Wc2006]水管局长数据加强版 LCT

题意:链接 方法: LCT 解析: 搞了一个上午加1个小时的题,TM最后大错误居然是排序元素太多排不回原来的样子! 我要重新学排序! 这题是用LCT维护动态最小生成树,但是最小生成树上删边应该是做不到的,所以我们可以离线操作,之后先把所有该删的边删了然后倒着搞所有询问,这样删边就变成了加边,之后询问就是x到y路径上的最大边权. 图是动态的,所以想到LCT,但是LCT不能搞最大边权怎么办! 把每个边看做一个点. 假设这是第i个边,那么把他看做第i+n个点. 显然点权就是边权,然后将这个边连接的两个