【BZOJ2001】[HNOI2010]城市建设（CDQ分治，线段树分治）

最新推荐文章于 2019-10-10 16:27:34 发布
最新推荐文章于 2019-10-10 16:27:34 发布
阅读量102 收藏
点赞数
原文链接：http://www.cnblogs.com/cjyyb/p/9845667.html
版权

【BZOJ2001】[HNOI2010]城市建设（CDQ分治，线段树分治）

题面

BZOJ
洛谷

题解

好神仙啊这题。原来想做一直不会做(然而YCB神仙早就切了），今天来怒写一发。

很明显这个玩意换种做法可以用线段树分治做，那么只需要\(LCT\)动态维护一下\(LCT\)就好了，时间复杂度？似乎是\(O(nlog^2m)\)的，每条边放在线段树上是一个\(log\)的，\(LCT\)还要一个\(log\)，然而常数十分大，大得一匹，洛谷上只能过\(80\)分。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<vector>
using namespace std;
#define ll long long
#define MAX 50050
#define ls (t[x].ch[0])
#define rs (t[x].ch[1])
#define lson (now<<1)
#define rson (now<<1|1)
inline int read()
{
    int x=0;bool t=false;char ch=getchar();
    while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();
    if(ch=='-')t=true,ch=getchar();
    while(ch<='9'&&ch>='0')x=x*10+ch-48,ch=getchar();
    return t?-x:x;
}
struct Line{int u,v,w;}E[MAX<<2];
int n,m,Q,L[MAX];
vector<int> t[MAX<<2];
struct LCT
{
    struct Node{int ch[2],ff,rev,v,mx;}t[MAX<<2];
    int S[MAX<<2],top;
    bool isroot(int x){return t[t[x].ff].ch[0]!=x&&t[t[x].ff].ch[1]!=x;}
    void pushdown(int x){if(t[x].rev)t[ls].rev^=1,t[rs].rev^=1,t[x].rev=0,swap(ls,rs);}
    void pushup(int x)
        {
            t[x].mx=x;
            if(ls&&t[t[ls].mx].v>t[t[x].mx].v)t[x].mx=t[ls].mx;
            if(rs&&t[t[rs].mx].v>t[t[x].mx].v)t[x].mx=t[rs].mx;
        }
    void rotate(int x)
        {
            int y=t[x].ff,z=t[y].ff;
            int k=t[y].ch[1]==x;
            if(!isroot(y))t[z].ch[t[z].ch[1]==y]=x;t[x].ff=z;
            t[y].ch[k]=t[x].ch[k^1];t[t[x].ch[k^1]].ff=y;
            t[x].ch[k^1]=y;t[y].ff=x;
            pushup(y);pushup(x);
        }
    void Splay(int x)
        {
            S[top=1]=x;
            for(int i=x;!isroot(i);i=t[i].ff)S[++top]=t[i].ff;
            while(top)pushdown(S[top--]);
            while(!isroot(x))
            {
                int y=t[x].ff,z=t[y].ff;
                if(!isroot(y))
                    (t[y].ch[0]==x)^(t[z].ch[0]==y)?rotate(x):rotate(y);
                rotate(x);
            }
        }
    int getroot(int x){access(x);Splay(x);while(ls)x=ls;return x;}
    void access(int x){for(int y=0;x;y=x,x=t[x].ff)Splay(x),rs=y,pushup(x);}
    void makeroot(int x){access(x);Splay(x);t[x].rev^=1;}
    void split(int x,int y){makeroot(x);access(y);Splay(y);}
    void cut(int x,int y){split(x,y);t[x].ff=t[y].ch[0]=0;pushup(y);}
    void link(int x,int y){makeroot(x);t[x].ff=y;}
    int Query(int x,int y){split(x,y);return t[y].mx;}
}T;
void Modify(int now,int l,int r,int L,int R,int x)
{
    if(L>R)return;
    if(L<=l&&r<=R){t[now].push_back(x);return;}
    int mid=(l+r)>>1;
    if(L<=mid)Modify(lson,l,mid,L,R,x);
    if(R>mid)Modify(rson,mid+1,r,L,R,x);
}
int SS[MAX<<2],st[MAX<<2];
ll Ans,ans[MAX];int Stop;
void Query(int now,int l,int r)
{
    //Add edge
    int ltop=Stop,mid=(l+r)>>1;
    for(int i=0,l=t[now].size();i<l;++i)
    {
        int p=t[now][i],u=E[p].u,v=E[p].v,w=E[p].w;
        if(T.getroot(u)==T.getroot(v))
        {
            int mx=T.Query(u,v);
            if(T.t[mx].v>w)
            {
                T.cut(E[mx-n].u,mx),T.cut(E[mx-n].v,mx),Ans-=E[mx-n].w;
                SS[++Stop]=mx-n;st[Stop]=1;
            }
            else continue;
        }
        T.link(p+n,u);T.link(p+n,v);Ans+=w;
        SS[++Stop]=p;st[Stop]=-1;
    }
    if(l==r)ans[l]=Ans;
    else Query(lson,l,mid),Query(rson,mid+1,r);
    for(int i=Stop;i>ltop;--i)
        if(st[i]<0)T.cut(SS[i]+n,E[SS[i]].u),T.cut(SS[i]+n,E[SS[i]].v),Ans-=E[SS[i]].w;
        else T.link(SS[i]+n,E[SS[i]].u),T.link(SS[i]+n,E[SS[i]].v),Ans+=E[SS[i]].w;
    Stop=ltop;
}
int pos[MAX],cnt;
int main()
{
    n=read();m=read();Q=read();cnt=m;
    for(int i=1;i<=m;++i)pos[i]=i;
    for(int i=1;i<=m;++i)E[i].u=read(),E[i].v=read(),E[i].w=read(),L[i]=1;
    for(int i=1;i<=Q;++i)
    {
        int k=read(),d=read(),x=pos[k];
        Modify(1,1,Q,L[k],i-1,x);L[k]=i;
        E[++cnt]=E[x];E[cnt].w=d;pos[k]=cnt;
    }
    for(int i=1;i<=cnt;++i)T.t[i+n].v=E[i].w;
    for(int i=1;i<=m;++i)Modify(1,1,Q,L[i],Q,pos[i]);
    Query(1,1,Q);
    for(int i=1;i<=Q;++i)printf("%lld\n",ans[i]);
    return 0;
}

然而正解的\(CDQ\)分治太神仙了，以至于我花了很久才咕完这题。
思路很容易讲清楚：
每次考虑当前的所有边，我们考虑我们的分治区间，有些边会被修改，有些边不会被修改。会在区间内被修改的边我们显然只能递归处理，考虑不会被修改的边，那么这些边只有三种情况：第一种是必定在\(MST\)的边，那么这些边我们直接连上，这样子可以缩点。另外一种边是一定不会出现在\(MST\)的边，那么这种边我们直接丢掉就好了。还有一种是不知道的边，那么我们直接递归处理即可。
时间复杂度？不会证，听说两个\(log\)。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
#define ll long long
#define MAX 50050
#define inf 1e9
inline int read()
{
    int x=0;bool t=false;char ch=getchar();
    while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();
    if(ch=='-')t=true,ch=getchar();
    while(ch<='9'&&ch>='0')x=x*10+ch-48,ch=getchar();
    return t?-x:x;
}
struct Line{int u,v,w,id;}E[MAX],St[MAX],e[30][MAX],tmp[MAX];
bool operator<(Line a,Line b){return a.w<b.w;}
struct Query{int x,w;}q[MAX];
int n,m,Q;ll ans[MAX];
int f[MAX],c[MAX],cnt;
int getf(int x){return x==f[x]?x:f[x]=getf(f[x]);}
void init(int x)
{
    for(int i=1;i<=x;++i)f[tmp[i].u]=tmp[i].u;
    for(int i=1;i<=x;++i)f[tmp[i].v]=tmp[i].v;
}
int W[MAX],size[50];
void Contraction(int &z,ll &Ans)
{
    init(z);sort(&tmp[1],&tmp[z+1]);int top=0;
    for(int i=1;i<=z;++i)
        if(getf(tmp[i].u)!=getf(tmp[i].v))
            f[getf(tmp[i].u)]=getf(tmp[i].v),St[++top]=tmp[i];
    for(int i=1;i<=top;++i)f[St[i].u]=St[i].u,f[St[i].v]=St[i].v;
    for(int i=1;i<=top;++i)//Get the edge must be used
        if(St[i].w>-inf)
            f[getf(St[i].u)]=getf(St[i].v),Ans+=St[i].w;
    top=0;
    for(int i=1;i<=z;++i)
        if(getf(tmp[i].u)!=getf(tmp[i].v))//Get the edge may be used
        {
            St[++top]=tmp[i];
            c[tmp[i].id]=top;
            St[top].u=getf(tmp[i].u);
            St[top].v=getf(tmp[i].v);
        }
    z=top;for(int i=1;i<=top;++i)tmp[i]=St[i];
}
void Reduction(int &z)
{
    init(z);sort(&tmp[1],&tmp[z+1]);int top=0;
    for(int i=1;i<=z;++i)//Delete the edge will 
        if(getf(tmp[i].u)!=getf(tmp[i].v))
            f[getf(tmp[i].u)]=getf(tmp[i].v),St[++top]=tmp[i],c[tmp[i].id]=top;
        else if(tmp[i].w>=inf)St[++top]=tmp[i],c[tmp[i].id]=top;
    z=top;for(int i=1;i<=top;++i)tmp[i]=St[i];
}
void CDQ(int l,int r,int dep,ll Ans)
{
    if(l==r)W[q[l].x]=q[l].w;//modify
    int z=size[dep],mid=(l+r)>>1;
    for(int i=1;i<=z;++i)e[dep][i].w=W[e[dep][i].id];
    for(int i=1;i<=z;++i)tmp[i]=e[dep][i],c[tmp[i].id]=i;
    if(l==r)//Get MST
    {
        init(z);sort(&tmp[1],&tmp[z+1]);
        for(int i=1;i<=z;++i)
            if(getf(tmp[i].u)!=getf(tmp[i].v))
                f[getf(tmp[i].u)]=getf(tmp[i].v),Ans+=tmp[i].w;
        ans[l]=Ans;return;
    }
    for(int i=l;i<=r;++i)tmp[c[q[i].x]].w=-inf;
    Contraction(z,Ans);
    for(int i=l;i<=r;++i)tmp[c[q[i].x]].w=+inf;
    Reduction(z);
    for(int i=1;i<=z;++i)e[dep+1][i]=tmp[i];size[dep+1]=z;
    CDQ(l,mid,dep+1,Ans);CDQ(mid+1,r,dep+1,Ans);
}
int main()
{
    n=read();m=read();Q=read();
    for(int i=1;i<=m;++i)E[i].u=read(),E[i].v=read(),E[i].w=read(),E[i].id=i;
    for(int i=1;i<=Q;++i)q[i].x=read(),q[i].w=read();
    for(int i=1;i<=m;++i)W[i]=E[i].w;
    for(int i=1;i<=m;++i)e[0][i]=E[i];
    size[0]=m;CDQ(1,Q,0,0);
    for(int i=1;i<=Q;++i)printf("%lld\n",ans[i]);
    return 0;
}

转载于:https://www.cnblogs.com/cjyyb/p/9845667.html

weixin_30312557
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
bzoj4530: [Bjoi2014]大融合 //线段树分治+并查集
蒟蒻名曰Starria
12-25 547
bzoj4530: [Bjoi2014]大融合 题意 N<=1e5个点，Q<=1e5个操作。 支持加一条边(u,v)（保证图是森林）、询问经过边(u,v)的简单路径条数（保证(u,v)存在）。 如果不算询问的那条边，那么答案就是当前u的联通块大小*v的联通块大小。 所以每条边原本的出现时间（加边的时间~结束）会被询问分隔成几段，所有边的总段数依然是Q级别的。
bzoj 3730. 震波（动态点分治 + vector树状数组）
01-06
（自己写的动态点分治巨垃圾，常数是别人的两倍） 用动态开点线段树死活过不去，学了一波大佬用 vector 开树状数组立马就卡过去了 考虑点分树的做法，在点分树上每个点以距离为下标建一棵线段树，每次询问查询子树的...
【CDQ分治】[HNOI2010]城市建设
03-13 142
题目链接 线段树分治+LCT只有80 然后就有了CDQ分治的做法 把不可能在生成树里的扔到后面 把一定在生成树里的扔到并查集里存起来 分治到l=r，修改边权，跑个kruskal就行了 由于要支持撤销，并查集要按秩合并 #include"cstdio" #include"cstring" #include"iostream" #include"algorithm" using namesp...
【BZOJ4025】 二分图（线段树分治）
araw94333的博客
03-27 158
传送门 BZOJ Solution 只是为了学习一下线段树分治的啦！ 当你学会线段树分治之后，可以跳过下面的一部分： 按照时间搞一颗线段树出来，把包含这段区间的操作用vector压进去。 每一个线段树的节点代表一段时间（没问题吧） 到了某一个节点，把这个节点上面的所有操作做好，然后递归儿子，最后消除影响。 接下来的就是这道题目怎么做了。 显然可以带权并查集维护是否是个二分图对吧。然后...
【bzoj4184】shallot
Joky_2002的博客
03-22 228
4184: shallotTime Limit: 30 Sec  Memory Limit: 128 MBSubmit: 668  Solved: 339[Submit][Status][Discuss]Description小苗去市场上买了一捆小葱苗，她突然一时兴起，于是她在每颗小葱苗上写上一个数字，然后把小葱叫过来玩游戏。每个时刻她会给小葱一颗小葱苗或者是从小葱手里拿走一颗小葱苗，并且让小葱从...
【BZOJ3236】【AHOI2013】作业 线段树 分治 树状数组
ez_yww的博客
10-31 594
题目描述　　给你一个长度为nn的数列，还有mm个询问，对于每个询问(l,r,a,b)(l,r,a,b)，输出1.区间[l,r][l,r]有多少范围在[a,b][a,b]的数；2.区间[l,r][l,r]有多少范围在[a,b][a,b]的权值。　　n≤100000,m≤1000000n\leq 100000,m\leq 1000000题解　　这道题莫队可以水过。　　这里讲一个更优秀的算法。　　建一棵权
wangjunrui666#bzoj-problem##2000. [Hnoi2010]stone 取石头游戏1
07-25
然后两个玩家轮流来取石子，每次每个玩家可以取走一堆中的所有石子，但有一个限制条件：一个玩家若要取走一堆石子，则与这堆石子相邻的某堆石子已被取走(之前被某个玩家取
BZOJ第一部分
11-03
BZOJ原题-BZOJP1000-P2000的题目，下载后可以离线做题。
BZOJ全代码
02-05
BZOJ平台全部代码，解压到一个文件夹在打开使用。BZOJ平台全部代码，解压到一个文件夹在打开使用。
BZOJ3230相似子串测试数据
08-19
BZOJ3230相似子串的测试数据，希望能够帮到大家。
BZOJ4311 向量（线段树分治+三分）
weixin_30847271的博客
10-25 90
　　由点积的几何意义（即投影）可以发现答案一定在凸壳上，并且投影的变化是一个单峰函数，可以三分。现在需要处理的只有删除操作，线段树分治即可。 #include<iostream> #include<cstdio> #include<cmath> #include<cstdlib> #include<cstring> #i...
线段树分治
hanjinbo的博客
04-14 306
（loj121）给你一张无向图，你要支持如下操作： 1：删除一条边 2：加入一条边 3：查询某两个点对间是否联通 ①在线做法：LCT ②离线做法：线段树分治 口胡做法： 把操作的顺序当做时间。 每条边维护一个存活区间，代表这条边在这个时间区间里面活着。 对时间轴建立一颗线段树，从线段树根开始dfs。 进入一个子树就把它这个子树中完全存活的边的两个点用按秩合并并查集合并。 一直到一个叶子的时候统计答...
BZOJ4025 二分图 [线段树分治]
Zbr162的博客
10-10 190
/# 二分图二分图二分图 题目描述见链接 . /## 正解部分\color{red}{正解部分}正解部分 先考虑如何判断是否 二分图, 可以使用 带权并查集 实现, 具体来说: 加入边 x,yx, yx,y 时, 设其祖先分别为 t1t_1t1​, t2t_2t2​, t1=t2t_1 = t_2t1​=t2​, 若 d[x]⨁d[y]⨁1d[x] \bigoplus d[y] \bigopl...
BZOJ 4644: 经典傻逼题 线段树分治 线性基
BlackJack
08-18 646
4644: 经典傻逼题 Time Limit: 10 Sec  Memory Limit: 512 MB Submit: 135  Solved: 66 [Submit][Status][Discuss] Description 这是一道经典傻逼题，对经典题很熟悉的人也不要激动，希望大家不要傻逼。 考虑一张N个点的带权无向图，点的编号为1到N。 对于图中的任意一个点集 （可以为空
[BZOJ4644]经典傻逼题-线段树分治-线性基
「嫌われ者のフィロソフィ」
01-06 1009
经典傻逼题Description这是一道经典傻逼题，对经典题很熟悉的人也不要激动，希望大家不要傻逼。 考虑一张N个点的带权无向图，点的编号为1到N。 对于图中的任意一个点集（可以为空或者全集），所有恰好有一个端点在这个点集中的边组成的集合被称为割。 一个割的权值被定义为所有在这个割上的边的异或和。 一开始这张图是空图， 现在，考虑给这张无向图不断的加边， 加入每条边之后，你都要求出当前权值最大的
bzoj4184 shallot（线段树分治+线性基）
Bfk的博客
01-03 508
bzoj4184 shallot原题地址：http://www.lydsy.com/JudgeOnline/problem.php?id=4184题意： 每个时刻小苗会给小葱一颗小葱苗或者是从小葱手里拿走一颗小葱苗，并且让小葱从自己手中的小葱苗里选出一些小葱苗使得选出的小葱苗上的数字的异或和最大。 这种小问题对于小葱来说当然不在话下，但是他的身边没有电脑，于是他打电话给同为Oi选手的你，你能帮帮
【BZOJ】2001 [Hnoi2010]City 城市建设 cdq分治——动态最小生成树
poursoul
09-10 3291
传送门：【BZOJ】2001  [Hnoi2010]City 城市建设
【BZOJ2773】ispiti【CDQ分治】【线段树】
BraketBN
04-28 655
【题目链接】 很容易看出来是CDQ分治，但是细节比较多。 令B为x轴，A为y轴... 给x轴排序要按降序排，而且当插入与查询在同一个点时，要先查询再插入，这样就不用维护次小值了。 光给操作离散化了，忘了给点离散化...导致大数据GG。 /* Pigonometry */ #include #include #include using namespace
BZOJ4025二分图题解（线段树分治+并查集）
hzk_cpp的博客
04-01 353
题目：BZOJ4025. 题目大意：给定一张nnn个点mmm条边的无向图，以及每条边的出现时间段[li,ri][l_i,r_i][li​,ri​]，问每个时间点的图是否是二分图. 1≤n≤105,1≤m≤2∗1051\leq n\leq 10^5,1\leq m\leq 2*10^51≤n≤105,1≤m≤2∗105，结束时间≤105\leq 10^5≤105. LCT做法. 考虑二分图的性质，...
bzoj 1040 zjoi2008 骑士 树形dp
最新发布
08-08
我们可以使用树形dp来解决这个问题，具体来说，我们可以将这个图看作是一棵树，每个点的父节点是它的前驱或者后继，然后我们从根节点开始，依次向下遍历，对于每个节点，我们可以考虑它的两个儿子，如果它的两个儿子...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值