线段树区间合并（单点更新+查找包含该位置的最长连续全1串）

最新推荐文章于 2024-09-15 10:50:49 发布

black_horse2018-Dong

最新推荐文章于 2024-09-15 10:50:49 发布

阅读量295

点赞数

分类专栏：数据结构

本文链接：https://blog.csdn.net/black_horse2018/article/details/89790189

版权

数据结构专栏收录该内容

18 篇文章 0 订阅

订阅专栏

Tunnel Warfare

Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 15230 Accepted Submission(s): 6019

Problem Description

During the War of Resistance Against Japan, tunnel warfare was carried out extensively in the vast areas of north China Plain. Generally speaking, villages connected by tunnels lay in a line. Except the two at the ends, every village was directly connected with two neighboring ones.

Frequently the invaders launched attack on some of the villages and destroyed the parts of tunnels in them. The Eighth Route Army commanders requested the latest connection state of the tunnels and villages. If some villages are severely isolated, restoration of connection must be done immediately!

Input

The first line of the input contains two positive integers n and m (n, m ≤ 50,000) indicating the number of villages and events. Each of the next m lines describes an event.

There are three different events described in different format shown below:

D x: The x-th village was destroyed.

Q x: The Army commands requested the number of villages that x-th village was directly or indirectly connected with including itself.

R: The village destroyed last was rebuilt.

Output

Output the answer to each of the Army commanders’ request in order on a separate line.

Sample Input

7 9

D 3

D 6

D 5

Q 4

Q 5

Q 4

Sample Output

Source

POJ Monthly

Recommend

LL | We have carefully selected several similar problems for you: 1542 1394 1166 1255 1754

题解：（参考：https://blog.csdn.net/Diogenes_/article/details/80471916）

#include<set>
#include<map>
#include<list>
#include<queue>
#include<stack>
#include<math.h>
#include<vector>
#include<bitset>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#define eps (1e-8)
#define MAX 0x3f3f3f3f
#define u_max 1844674407370955161
#define l_max 9223372036854775807
#define i_max 2147483647
#define re register
#define nth(k,n) nth_element(a,a+k,a+n);  // 将 第K大的放在k位
#define ko() for(int i=2;i<=n;i++) s=(s+k)%i // 约瑟夫
#define ok() v.erase(unique(v.begin(),v.end()),v.end()) // 排序,离散化
using namespace std;

inline int read(){
    char c = getchar(); int x = 0, f = 1;
    while(c < '0' || c > '9') {if(c == '-') f = -1; c = getchar();}
    while(c >= '0' & c <= '9') x = x * 10 + c - '0', c = getchar();
    return x * f;
}

typedef long long ll;
const double pi = atan(1.)*4.;
const int M=1e3+5;
const int N=5e4+5;
int n,m;

struct fun{
    int lsum,rsum,sum;    // 上边有定义
}tree[N<<2];

void sett(int l,int r,int rt){       // 与普通线段树一样，初始化底层全为 1
    if(l==r){
        tree[rt].sum=tree[rt].lsum=tree[rt].rsum=1;
        return ;
    }
    int mid=l+r>>1;
    sett(l,mid,rt<<1);
    sett(mid+1,r,rt<<1|1);
    tree[rt].sum=tree[rt].lsum=tree[rt].rsum=r-l+1;
}

void pushup(int l,int r,int rt){
    int mid=l+r>>1;    // 左儿子区间(l,mid)  右儿子区间(mid+1,r)
    tree[rt].lsum=tree[rt<<1].sum==(mid-l+1)?   // 左儿子区间全是1
                  tree[rt<<1].sum+tree[rt<<1|1].lsum:tree[rt<<1].lsum;
    tree[rt].rsum=tree[rt<<1|1].sum==(r-mid)?   // 右儿子区间全是1
                  tree[rt<<1|1].sum+tree[rt<<1].rsum:tree[rt<<1|1].rsum;
    
    tree[rt].sum=max((tree[rt<<1].rsum+tree[rt<<1|1].lsum),
                      max(tree[rt<<1].sum,tree[rt<<1|1].sum));
    return ;
}

void upset(int x,bool flag,int l,int r,int rt){
    if(l==r){
        if(flag) tree[rt].sum=tree[rt].lsum=tree[rt].rsum=1;
        else  tree[rt].sum=tree[rt].lsum=tree[rt].rsum=0;
        return ;
    }
    int mid=l+r>>1;
    if(x<=mid) upset(x,flag,l,mid,rt<<1);
    else upset(x,flag,mid+1,r,rt<<1|1);
    pushup(l,r,rt);
}

int findd(int p,int l,int r,int rt){
    // 更新到最底层一个或该区间为 空 或 满
    if(l==r||tree[rt].sum==0||tree[rt].sum==(r-l+1)) 
        return tree[rt].sum;
    int mid=l+r>>1;
    if(p<=mid){   // p 在左子树
        // sl 代表 (mid-tree[rt<<1].rsum+1)  最长连续串的左端点（终点在 mid-> 左子树右端点）
        // 0 0 0 1 1 1 1 1 0 0
        //       ^   ^
        // l    sl  mid
        if(p>=(mid-tree[rt<<1].rsum+1))  
            return findd(p,l,mid,rt<<1)+findd(mid+1,mid+1,r,rt<<1|1);
        else
            return findd(p,l,mid,rt<<1);
    }
    else{
        //  同理
        if(p<=(mid+1)+tree[rt<<1|1].lsum-1)
            return findd(p,mid+1,r,rt<<1|1)+findd(mid,l,mid,rt<<1);
        else
            return findd(p,mid+1,r,rt<<1|1);
    }
}
stack<int>ss;
int main(){
    while(scanf("%d %d",&n,&m)!=EOF){
        while(!ss.empty()) ss.pop();
        memset(tree,0,sizeof(tree));
        sett(1,n,1);
        char c; int d;
        while(m--){
            scanf(" %c",&c);
            if(c=='D'){
                scanf("%d",&d);
                ss.push(d);
                upset(d,false,1,n,1);
            }
            else if(c=='Q'){
                scanf("%d",&d);
                printf("%d\n",findd(d,1,n,1));
            }
            else{
                d=ss.top();
                ss.pop();
                upset(d,true,1,n,1);
            }
        }
    }
    return 0;
}

1562 玻璃切割

2 秒
131,072 KB
20 分
3 级题

现在有一块玻璃，是长方形的（w 毫米× h 毫米），现在要对他进行切割。

切割的方向有两种，横向和纵向。每一次切割之后就会有若干块玻璃被分成两块更小的玻璃。在切割之后玻璃不会被移动。

现在想知道每次切割之后面积最大的一块玻璃是多少。

样例解释：

对于第四次切割，下面四块玻璃的面积是一样大的。都是2。

收起

输入

单组测试数据。
第一行有三个整数 w,h,n (2≤w,h≤200000, 1≤n≤200000)，表示玻璃在横向上长w 毫米，纵向上长h 毫米，接下来有n次的切割。
接下来有n行输入，每一行描述一次切割。
输入的格式是H y 或 V x。
H y表示横向切割，切割线距离下边缘y毫米(1≤y≤h-1)。
V x表示纵向切割，切割线距离左边缘x毫米(1≤x≤w-1)。
输入保证不会有两次切割是一样的。

输出

对于每一次切割，输出所有玻璃中面积最大的是多少。

输入样例

样例输入1
4 3 4
H 2
V 2
V 3
V 1

输出样例

样例输出1
8
4
4
2

题解：由于分割的时候是直线，所以每次最大的面积是 max(w) * max(h)

用两颗线段树维护行和列的最大连续 1 串，0的地方代表分割，1的地方代表不分割。

注：我的解法：行和列都 + 1 ，同时将4边都赋值为 0，最后查询返回的答案 +1；

#include<set>
#include<map>
#include<list>
#include<queue>
#include<stack>
#include<math.h>
#include<vector>
#include<bitset>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#define eps (1e-8)
#define MAX 0x3f3f3f3f
#define u_max 1844674407370955161
#define l_max 9223372036854775807
#define i_max 2147483647
#define re register
#define pushup() tree[rt]=max(tree[rt<<1],tree[rt<<1|1])
#define nth(k,n) nth_element(a,a+k,a+n);  // 将 第K大的放在k位
#define ko() for(int i=2;i<=n;i++) s=(s+k)%i // 约瑟夫
#define ok() v.erase(unique(v.begin(),v.end()),v.end()) // 排序,离散化
using namespace std;

inline int read(){
    char c = getchar(); int x = 0, f = 1;
    while(c < '0' || c > '9') {if(c == '-') f = -1; c = getchar();}
    while(c >= '0' & c <= '9') x = x * 10 + c - '0', c = getchar();
    return x * f;
}

typedef long long ll;
const double pi = atan(1.)*4.;
const int M=1e3+5;
const int N=2e5+5;
int w,h,n;

struct fun{
    int lsum,rsum,sum;
}row[N<<2],col[N<<2];


void sett1(int l,int r,int rt){
    if(l==r){
        row[rt].sum=row[rt].lsum=row[rt].rsum=1;
        return ;
    }
    int mid=l+r>>1;
    sett1(l,mid,rt<<1);
    sett1(mid+1,r,rt<<1|1);
    row[rt].sum=row[rt].lsum=row[rt].rsum=r-l+1;
}

void sett2(int l,int r,int rt){
    if(l==r){
        col[rt].sum=col[rt].lsum=col[rt].rsum=1;
        return ;
    }
    int mid=l+r>>1;
    sett2(l,mid,rt<<1);
    sett2(mid+1,r,rt<<1|1);
    col[rt].sum=col[rt].lsum=col[rt].rsum=r-l+1;
}

void pushup1(int l,int r,int rt){
    int mid=l+r>>1;
    row[rt].lsum=row[rt<<1].sum==(mid-l+1)?
                 row[rt<<1].sum+row[rt<<1|1].lsum:row[rt<<1].lsum;
    row[rt].rsum=row[rt<<1|1].sum==(r-mid)?
                 row[rt<<1|1].sum+row[rt<<1].rsum:row[rt<<1|1].rsum;
    row[rt].sum=max((row[rt<<1].rsum+row[rt<<1|1].lsum),
                     max(row[rt<<1].sum,row[rt<<1|1].sum));
}

void pushup2(int l,int r,int rt){
    int mid=l+r>>1;
    col[rt].lsum=col[rt<<1].sum==(mid-l+1)?
                 col[rt<<1].sum+col[rt<<1|1].lsum:col[rt<<1].lsum;
    col[rt].rsum=col[rt<<1|1].sum==(r-mid)?
                 col[rt<<1|1].sum+col[rt<<1].rsum:col[rt<<1|1].rsum;
    col[rt].sum=max((col[rt<<1].rsum+col[rt<<1|1].lsum),
                     max(col[rt<<1].sum,col[rt<<1|1].sum));
}

void upset1(int p,bool flag,int l,int r,int rt){
    if(l==r){
        if(flag) row[rt].sum=row[rt].lsum=row[rt].rsum=1;
        else row[rt].sum=row[rt].lsum=row[rt].rsum=0;
        return ;
    }
    int mid=l+r>>1;
    if(p<=mid) upset1(p,flag,l,mid,rt<<1);
    else upset1(p,flag,mid+1,r,rt<<1|1);
    pushup1(l,r,rt);
}

void upset2(int p,bool flag,int l,int r,int rt){
    if(l==r){
        if(flag) col[rt].sum=col[rt].lsum=col[rt].rsum=1;
        else col[rt].sum=col[rt].lsum=col[rt].rsum=0;
        return ;
    }
    int mid=l+r>>1;
    if(p<=mid) upset2(p,flag,l,mid,rt<<1);
    else upset2(p,flag,mid+1,r,rt<<1|1);
    pushup2(l,r,rt);
}


int main(){
    char c; int d;
    scanf("%d %d %d",&w,&h,&n);
    w++; h++;
    sett1(1,w,1); sett2(1,h,1);
    upset1(1,false,1,w,1);  upset1(w,false,1,w,1);
    upset2(1,false,1,h,1);  upset2(h,false,1,h,1);
   // printf("w == %d  h == %d\n",row[1].sum,col[1].sum);
    int leap1=0,leap2=0;
    for(int i=0;i<n;i++){
        scanf(" %c %d",&c,&d);
        if(c=='H') { leap2=1;  upset2(h-d,false,1,h,1); }
        else { leap1=1;  upset1(d+1,false,1,w,1); }
        ll ans1=1ll*row[1].sum+1;
        ll ans2=1ll*col[1].sum+1;
      //  printf("ans1 == %lld  ans2 == %lld\n",ans1,ans2);
        printf("%lld\n",ans1*ans2);
    }
    return 0;
}