CodeForces 527C. Glass Carving （SBT，线段树，set，最长连续0）

最新推荐文章于 2021-09-22 17:38:20 发布
最新推荐文章于 2021-09-22 17:38:20 发布
阅读量123 收藏
点赞数
原文链接：http://www.cnblogs.com/jiamian/p/11289137.html
版权

原题地址：http://codeforces.com/problemset/problem/527/C

 

Examples

input

4 3 4
H 2
V 2
V 3
V 1

output

8
4
4
2

input

7 6 5
H 4
V 3
V 5
H 2
V 1

output

28
16
12
6
4

 

题意是给定一个矩形，不停地纵向或横向切割，问每次切割后，最大的矩形面积是多少。


最大矩形面积=最长的长*最宽的宽
这题，长宽都是10^5，所以，用0 1序列表示每个点是否被切割，然后，
最长的长就是长的最长连续0的数量+1
最长的宽就是宽的最长连续0的数量+1
于是用线段树维护最长连续零

问题转换成：
目标信息：区间最长连续零的个数
点信息：0 或 1
由于目标信息不符合区间加法，所以要扩充目标信息。

转换后的线段树结构：
区间信息：从左，右开始的最长连续零，本区间是否全零，本区间最长连续零。
点信息：0 或 1
然后还是那2个问题：

1.区间加法：
这里，一个区间的最长连续零，需要考虑3部分：
-（1）：左子区间最长连续零
-（2）：右子区间最长连续零
-（3）：左右子区间拼起来，而在中间生成的连续零（可能长于两个子区间的最长连续零）
而中间拼起来的部分长度，其实是左区间从右开始的最长连续零+右区间从左开始的最长连续零。
所以每个节点需要多两个量，来存从左右开始的最长连续零。
然而，左开始的最长连续零分两种情况，
--（1）：左区间不是全零，那么等于左区间的左最长连续零
--（2）：左区间全零，那么等于左区间0的个数加上右区间的左最长连续零
于是，需要知道左区间是否全零，于是再多加一个变量。
最终，通过维护4个值，达到了维护区间最长连续零的效果。

2.点信息->区间信息 ： 
如果是0，那么  最长连续零=左最长连续零=右最长连续零=1 ，全零=true。
如果是1，那么  最长连续零=左最长连续零=右最长连续零=0， 全零=false。

至于修改和查询，有了区间加法之后，机械地写一下就好了。
由于这里其实只有对整个区间的查询，所以查询函数是不用写的，直接找根的统计信息就行了。

递归线段树：

 1 #include <stdio.h>
 2 #include <string.h>
 3 #include <iostream>
 4 #include <string>
 5 #include <math.h>
 6 #include <algorithm>
 7 #include <queue>
 8 #include <set>
 9 #include <math.h>
10 const int INF=0x3f3f3f3f;
11 typedef long long LL;
12 const int maxn=2e5+10;
13 using namespace std;
14  
15  
16 struct SegTree{
17     int ls;//左最长连续零 
18     int rs;//右最长连续零 
19     int max0;//最长连续零 
20     bool is_all0;//是否全为零 
21 }tree[2][maxn<<2];
22  
23 void PushUp(int rt,int flag)//区间加法 
24 {
25     SegTree &root=tree[flag][rt];
26     SegTree &lc=tree[flag][rt<<1];
27     SegTree &rc=tree[flag][rt<<1|1];
28     root.ls=lc.ls+(lc.is_all0?rc.ls:0);
29     root.rs=rc.rs+(rc.is_all0?lc.rs:0);
30     root.max0=max(lc.rs+rc.ls,max(lc.max0,rc.max0));
31     root.is_all0=lc.is_all0&&rc.is_all0;
32 }
33  
34 void Build(int l,int r,int rt,int flag)//建树 
35 {
36     if(l==r)
37     {
38         tree[flag][rt].ls=tree[flag][rt].rs=tree[flag][rt].max0=1;
39         tree[flag][rt].is_all0=true;
40         return ;
41     }
42     int m=(l+r)>>1;
43     Build(l,m,rt<<1,flag);
44     Build(m+1,r,rt<<1|1,flag);
45     PushUp(rt,flag);
46 }
47  
48 void Update(int l,int r,int rt,int pos,int flag)//更新 
49 {
50     if(l==r)
51     {
52         tree[flag][rt].ls=tree[flag][rt].rs=tree[flag][rt].max0=0;
53         tree[flag][rt].is_all0=false;
54         return ;
55     }
56     int m=(l+r)>>1;
57     if(pos<=m)
58         Update(l,m,rt<<1,pos,flag);
59     else
60         Update(m+1,r,rt<<1|1,pos,flag);
61     PushUp(rt,flag);
62 }
63  
64 int main()
65 {
66     int W,H,q,t;
67     char c[5];
68     scanf("%d %d %d",&W,&H,&q);
69     Build(1,W-1,1,0);
70     Build(1,H-1,1,1);
71     while(q--)
72     {
73         scanf("%s %d",&c,&t);
74         if(c[0]=='V')
75             Update(1,W-1,1,t,0);
76         else if(c[0]=='H')
77             Update(1,H-1,1,t,1);
78         printf("%lld\n",LL(tree[0][1].max0+1)*(tree[1][1].max0+1));//相乘可能整数溢出，记得类型装换 
79     }
80     return 0;
81 }

 

 

 

 

 

 

以下是大神写的，原地址：https://blog.csdn.net/zearot/article/details/44759437

 

 

多次切割求最大矩形面积：

大致思路，对两条边分别找出被切割出的每一段长度的最大值，相乘就是答案。

 

有三种实现方法：

一：线段树

用1和0 表示每一条可被切割的线是否被切割，然后用线段树统计最长连续零的个数。

时间复杂度O(n* max( log2(w) , log2(h))) 

 

二：SBT（Size Balanced Tree）

直接按顺序存下被切割之后的每一个小段的长度，每次切割的操作就是把其中的某个数分解成两个数。

比如开始长度为【11】，在3处切割：【3，8】。 然后在5处切割：【3，2，6】，在4处切割：【3，1，1，6】。

时间复杂度O(n * log2(n))

 

三：使用std::set

使用set存下被切割的横坐标，然后求该点的前驱和后继。就可以知道被切割的区间的长度。

然后另有数组存下每个区间长度出现的次数，每次操作维护这个次数。

 

方法比较：SBT:  202ms  4700KB     线段树：187ms 20400KB    std::set  171ms   7888KB

总的来说就是SBT占用空间小，但稍微慢一点（可能实现上还可以改进）

线段树占用空间大，但比SBT快一点（我试过了改成非递归线段树并没有比递归的快多少）

由于SBT的时间复杂度只与n有关，所以可以处理更大的w和h，通用性更强一些，但写起来也复杂一些。

相比之下，使用set由于不需要自己写一个树结构，编程复杂度比较低。

 

非递归线段树：

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cmath>
 4 #define maxn 200001
 5 using namespace std;
 6 int L[maxn<<2][2];//从左开始连续零个数 
 7 int R[maxn<<2][2];//从右 
 8 int Max[maxn<<2][2];//区间最大连续零 
 9 bool Pure[maxn<<2][2];//是否全零 
10 int M[2];
11 void PushUp(int rt,int k){//更新rt节点的四个数据 
12     Pure[rt][k]=Pure[rt<<1][k]&&Pure[rt<<1|1][k]; 
13     Max[rt][k]=max(R[rt<<1][k]+L[rt<<1|1][k],max(Max[rt<<1][k],Max[rt<<1|1][k]));
14     L[rt][k]=Pure[rt<<1][k]?L[rt<<1][k]+L[rt<<1|1][k]:L[rt<<1][k];
15     R[rt][k]=Pure[rt<<1|1][k]?R[rt<<1|1][k]+R[rt<<1][k]:R[rt<<1|1][k];
16 }
17 void Build(int n,int k){//建树，赋初值
18     for(int i=0;i<M[k];++i) L[M[k]+i][k]=R[M[k]+i][k]=Max[M[k]+i][k]=Pure[M[k]+i][k]=i<n;
19     for(int i=M[k]-1;i>0;--i) PushUp(i,k);
20 }
21 void Change(int X,int k){//切割，更新 
22     int s=M[k]+X-1;
23     Pure[s][k]=Max[s][k]=R[s][k]=L[s][k]=0;
24     for(s>>=1;s;s>>=1) PushUp(s,k);
25 } 
26 int main(void)
27 {
28     int w,h,n;
29     while(cin>>w>>h>>n){
30         //以下3行，找出非递归线段树的第一个数的位置。 
31         M[0]=M[1]=1;
32         while(M[0]<h-1) M[0]<<=1;
33         while(M[1]<w-1) M[1]<<=1;
34         //建树 
35         Build(h-1,0);Build(w-1,1);
36         
37         for(int i=0;i<n;++i){
38             //读取数据 
39             char x;int v;
40             scanf(" %c%d",&x,&v);
41             //切割 
42             x=='H'?Change(v,0):Change(v,1);
43             //输出 
44             printf("%I64d\n",(long long)(Max[1][0]+1)*(Max[1][1]+1));
45         }
46     }
47     return 0;
48 }
49

 

SBT：

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cmath>
 4 #define maxn 200007
 5 using namespace std;
 6 int L[maxn],R[maxn],Size[maxn];
 7 int Max[maxn],Sum[maxn],Key[maxn];
 8 int IP;
 9 void Init(){//初始化 
10     L[0]=R[0]=Size[0]=0;
11     Max[0]=Sum[0]=Key[0]=0;
12     IP=0;
13 }
14 void PushUp(int rt){//更新节点 
15     Size[rt]=1+Size[L[rt]]+Size[R[rt]];
16     Sum[rt]=Key[rt]+Sum[L[rt]]+Sum[R[rt]];
17     Max[rt]=max(Key[rt],max(Max[L[rt]],Max[R[rt]]));
18 }
19 void zig(int &rt){//左旋 
20     int t=R[rt];R[rt]=L[t];L[t]=rt;
21     PushUp(rt);PushUp(t);rt=t;
22 }
23 void zag(int &rt){//右旋 
24     int t=L[rt];L[rt]=R[t];R[t]=rt;
25     PushUp(rt);PushUp(t);rt=t;
26 }
27 void maintain(int &rt){//平衡 
28     if(Size[L[L[rt]]]>Size[R[rt]]) {zag(rt);maintain(R[rt]);maintain(rt);return;}
29     if(Size[R[R[rt]]]>Size[L[rt]]) {zig(rt);maintain(L[rt]);maintain(rt);return;}
30     if(Size[R[L[rt]]]>Size[R[rt]]) {zig(L[rt]);zag(rt);maintain(L[rt]);maintain(R[rt]);return;}
31     if(Size[L[R[rt]]]>Size[L[rt]]) {zag(R[rt]);zig(rt);maintain(R[rt]);maintain(L[rt]);return;} 
32 }
33 void InsertLeft(int &rt,int X){//在rt这课树的最左端插入，Insert的辅助函数 
34     if(rt) {
35         InsertLeft(L[rt],X);PushUp(rt);maintain(rt);
36     }
37     else {
38         rt=++IP;
39         Sum[rt]=Max[rt]=Key[rt]=X;
40         Size[rt]=1;L[rt]=R[rt]=0;
41     }
42 }
43 void Insert(int &rt,int X){//在X处切割 
44     if(X < Sum[L[rt]]) {Insert(L[rt],X);PushUp(rt);maintain(rt);return;}
45     X-=Sum[L[rt]];
46     if(X > Key[rt]){Insert(R[rt],X - Key[rt]);PushUp(rt);maintain(rt);return;}
47     InsertLeft(R[rt],Key[rt]-X);
48     Key[rt]=X;PushUp(rt);
49 }
50 int w,h,n;
51 int main(void)
52 {
53     while(cin>>w>>h>>n){
54         //初始化 
55         Init();
56         int H=0,V=0;  
57         InsertLeft(H,h);InsertLeft(V,w);
58         
59         for(int i=0;i<n;++i){
60             //读取 
61             char x;int v;
62             scanf(" %c%d",&x,&v);
63             //切割 
64             x=='H'?Insert(H,v):Insert(V,v);
65             //输出 
66             printf("%I64d\n",(long long)Max[H]*Max[V]);
67         }
68     }    
69     return 0;
70 }

 

std::set代码：

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstring>
 4 #include <set> 
 5 #define maxn 200001
 6 using namespace std;
 7 set<int>::iterator i,j;
 8 set<int> H,V;
 9 int Hn[maxn],Vn[maxn];
10 void Cut(set<int> &A,int *N,int v){//切割
11     A.insert(v);i=j=A.find(v);
12     --i,++j,--N[*j-*i];
13     ++N[v-*i],++N[*j-v];
14 }
15 int main(void)
16 {
17     int w,h,n;
18     while(cin>>w>>h>>n){
19         memset(Hn,0,sizeof(Hn));H.clear();H.insert(h);H.insert(0);Hn[h]=1;
20         memset(Vn,0,sizeof(Vn));V.clear();V.insert(w);V.insert(0);Vn[w]=1;
21         int MaxH=h,MaxW=w; //MaxH表示H的最大值
22         for(int i=0;i<n;++i){
23             //读取数据 
24             char x;int v;
25             scanf(" %c%d",&x,&v);
26             //切割 
27             x=='H'?Cut(H,Hn,v):Cut(V,Vn,v);
28             //输出 
29             while(!Hn[MaxH]) --MaxH;//更新最大值，由于最大值一定不增，所以整个这个操作是O(h)的
30             while(!Vn[MaxW]) --MaxW;//同上
31             printf("%I64d\n",(long long)MaxH*MaxW);
32         }
33     }
34     return 0;
35 }

 

转载于:https://www.cnblogs.com/jiamian/p/11289137.html

weixin_30299539
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
线段树维护区间最长连续0的长度
lalalafloat的博客
03-09 708
原理 本身区间最长连续0之间不可以进行区间加法操作，违背线段树基本的运算。但是容易想到两个区间合并产生的最值变化，主要由Lson的右端连续0长度加上Rson的左端连续0长度引起。即 tree[x].ma=max(tree[Lson].R0+tree[Rson].L0,max(tree[Lson].ma,tree[Rson].ma)); 因此我们可以考虑维护一个区间的左端连续0个数和右端连续0个数。...
线段树详解 （原理，实现与应用）
热门推荐
岩之痕
09-09 14万+
线段树详解 By 岩之痕 一：综述 线段树是一种可以快速进行区间修改和区间查询的数据结构。点修改，区间修改和区间查询的复杂度都是O(log2(n)) 并且，线段树可以维护很多种类的信息。说到线段树就不得不提一下树状数组，树状数组维护的信息必须满足区间减法，因为树状数组只是维护1到X的信息，通过相减来得到区间信息，代码简单而且速度快，占用空间又少于线段树，所以一般情况下可以用树状数组的地方就
HDU1540--线段树（最长连续区间）
ybacm的博客
11-27 1087
这个题目好像不是很难，可是我想了很久，还超时了。。我用的是普通线段树和二分，第一次用二分超时啊啊啊啊啊 好，让我们言归正传。（参考别的大佬的做法，贼6） 看到这个题目之后，能够想到它是为了求包含一个点的最大连续区间。那么多的区间，应该是要用线段树来做。 可以想得到，查询的时候，是从这个点展开，判断左右是否连续。 首先，我们用递归查询到这个点，或者说是包含这个点的连续区间，假设它是一个左子树
codeforces 527 C. Glass Carving
hao1001的博客
03-19 311
http://codeforces.com/problemset/problem/527/CC. Glass Carvingtime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputLeonid wants to become a glass carve...
CodeForces 527C：Glass Carving （set与multiset应用）
并非所有流浪者都迷失了自我
07-26 547
Leonid wants to become a glass carver (the person who creates beautiful artworks by cutting the glass). He already has a rectangular w mm  ×  h mm sheet of glass, a diamond glass cutter and lots of enthusiasm.
Codeforces 1324 F. Maximum White Subtree (树形dp) /详解
01-03
F. Maximum White Subtree time limit per test2 seconds memory limit per test256 megabytes inputstandard input outputstandard output You are given a tree consisting of n vertices. A tree is a connected ...
CodeForces_1348EF – Phoenix and Memory 贪心+线段树找区间最小值
01-03
用set维护可选的数即可。 这题加了个输出2个方案。 我们考虑最简单的情况：即确定一个序列后，是否有2个位置，posi，posj，使得i，j可以交换。 显然必须满足 Lj<=posi<posj<Ri 我们枚举i，只需要找到任意...
Codeforces 1083 A. The Fair Nut and the Best Path（树形DP）
01-03
codeforces每日一练。 题意: 给一棵树，每个点有一个点权，每条边有一个边权，求一条链使得点权和-边权和最大。 思路： 由于我没看清楚题意，以为是求联通子图的点权和-边权和最大，用link-cut-tree写换根，wa10了两...
Codeforces 721 C. Journey（拓扑排序+DP）
01-03
codeforces每日一练。 题意: 给定n个点，m条有向边，以及k时间。求不超过k时间1-n最多能经过多少个点。 思路： 数据<=5000，说明是个暴力dp。 那么可以用dp[i][j]维护从1到i点经过了j个点，然后初始化为inf，再设...
Codeforces 1333C. Eugene and an array（思维） /详解
01-08
Codeforces Round #632 (Div. 2) C. Eugene and an array 题意： 求出一个数列中子区间满足 此区间的任意子区间之和 不为0的区间个数。 思路: 考虑用dp[x]dp[x]dp[x]记录前缀和为xxx的区间右端点。 那么这道题其实...
codeforces#527 - C. Glass Carving （线段树）
Gverzh的博客
09-22 148
codeforces527 - C. Glass Carving 链接： https://codeforces.com/problemset/problem/527/C 题解链接： https://blog.csdn.net/scau_cdx/article/details/89893591 https://www.cnblogs.com/shuaihui520/p/9835973.html 求最长连续0区间 Code： #include <algorithm> #include <ios
Codeforces 527C Glass Carving(Set)
Deng's site \#
03-18 1356
题意  一块w*h的玻璃  对其进行n次切割  每次切割都是垂直或者水平的  输出每次切割后最大单块玻璃的面积 用两个set存储每次切割的位置   就可以比较方便的把每次切割产生和消失的长宽存下来  每次切割后剩下的最大长宽的积就是答案了 #include using namespace std; const int N = 200005; typedef long long LL; set
Codeforces 527C Glass Carving （最长连续0变形+线段树）
weixin_30780221的博客
10-23 142
Leonid wants to become a glass carver (the person who creates beautiful artworks by cutting the glass). He already has a rectangular w mm  ×  h mm sheet of glass, a diamond glass cutter and lots of en...
CodeForces - 527C Glass Carving（STL）
T__TSZ的博客
07-27 576
Leonid wants to become a glass carver (the person who creates beautiful artworks by cutting the glass). He already has a rectangular w mm  ×  h mm sheet of glass, a diamond glass cutter and lots of
【题解】codeforces765F Souvenirs
ZJZ的博客
02-27 601
题目链接 题意：给定一个长度为n的数组与m个查询。第i个查询要求输出数组下标区间[li,ri]内的数之间的距离（差的绝对值）的最小值。 分析：离线处理查询。将查询区间按右端点从小到大排序，维护一个数据结构，使得将数组元素a1,a2,...,ai插入到数据结构之后能够快速查询以ai为右端点的查询区间的答案。考虑ai对查询区间的贡献，设d=|ai-aj|(j         若暴力处理ai对查询
（CodeForces - 527C）Glass Carving
The wind of freedom blows
09-04 392
（CodeForces - 527C）Glass CarvingLeonid wants to become a glass carver (the person who creates beautiful artworks by cutting the glass). He already has a rectangular w mm  ×  h mm sheet of glass, a diamond glass
Codeforces 527C Glass Carving
XDU_PYL的博客
09-09 708
Leonid wants to become a glass carver (the person who creates beautiful artworks by cutting the glass). He already has a rectangular w mm  ×  h mm sheet of glass, a diamond glass cutter and lots of
Codeforces 527C Glass Carving 线段树区间合并
上决╇ф的ACM
03-30 1444
传送门：  http://codeforces.com/contest/527/problem/C C. Glass Carving time limit per test 2 seconds memory limit per test 256 megabytes input standard input output standard output Leoni
方案-基于云架构的校园信息化建设方案.pdf
最新发布
07-29
方案-基于云架构的校园信息化建设方案.pdf
https://codeforces.com/contest/1809/problem/C
03-29
- We define a variable to keep track of the total number of swaps made and set it to 0. - We run a loop from the first element to the second-to-last element. - In each iteration of the above loop, we ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值