【HDU 3911】Black and White 线段树 最长连续1个数

最新推荐文章于 2022-07-01 15:05:21 发布
原创 最新推荐文章于 2022-07-01 15:05:21 发布 · 330 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

博客介绍了如何利用线段树解决HDU 3911题目，该题涉及01序列和区间操作。通过定义连续1和0的线段树结构体，实现对序列的查询和反转操作，从而找到最长连续1的子序列。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

HDU 3911
题意 给你一个包含 n n n元素的01序列 有m次操作 0操作 输出 x 到 y 之间最长1个数
1 操作 将x y 区间内所有数取反
这道题去年六月份写过题解 不过是看不懂的一句话题解 今天重新总结一下这个题
类似这种区间可以通过一种性质 (左边,右边,中间)得到的题 我们用线段树去做
这题我们定义两个结构体 arr1 和 arr2 arr1就是原序列中 连续 1 的一颗树
arr2 就是 原序列中 连续 0的一棵树
你既然 1 操作使得一段区间反转 那么直接 1树和0树换一下即可
这是十个月前的有毒代码

#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <cmath>
#include <map>
#include <stack>
#include <set>
#include <sstream>
#include <vector>
#include <stdlib.h>
#include <algorithm>
using namespace std;

#define dbg(x) cout<<#x<<" = "<< (x)<< endl
#define dbg2(x1,x2) cout<<#x1<<" = "<<x1<<" "<<#x2<<" = "<<x2<<endl
#define dbg3(x1,x2,x3) cout<<#x1<<" = "<<x1<<" "<<#x2<<" = "<<x2<<" "<<#x3<<" = "<<x3<<endl
#define max3(a,b,c) max(a,max(b,c))
#define min3(a,b,c) min(a,min(b,c))
#define lc (rt<<1)
#define rc (rt<<11)
#define mid ((l+r)>>1)

typedef pair<int,int> pll;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const int _inf = 0xc0c0c0c0;
const ll INF = 0x3f3f3f3f3f3f3f3f;
const ll _INF = 0xc0c0c0c0c0c0c0c0;
const ll mod =  (int)1e9+7;

ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
ll ksm(ll a,ll b,ll mod){int ans=1;while(b){if(b&1) ans=(ans*a)%mod;a=(a*a)%mod;b>>=1;}return ans;}
ll inv2(ll a,ll mod){return ksm(a,mod-2,mod);}
int Max(int a,int b)
{
    if(a>b) return a;
    return b;
}
int Min(int a,int b)
{
    if(a<b) return b;
    return a;
}
const int MAX_N = 100025;
struct node
{
    int len_l,len_r,len,down;
}arr1[MAX_N<<2],arr0[MAX_N<<2];
void up(int rt,int l,int r)
{
    arr1[rt].len_l = arr1[rt<<1].len_l;
    if(arr1[rt].len_l==mid-l+1) arr1[rt].len_l+=arr1[rt<<1|1].len_l;
    arr1[rt].len_r = arr1[rt<<1|1].len_r;
    if(arr1[rt].len_r==r-mid) arr1[rt].len_r+=arr1[rt<<1].len_r;
    arr1[rt].len = Max(arr1[rt<<1].len,arr1[rt<<1|1].len);
    arr1[rt].len = Max(arr1[rt].len,Max(arr1[rt<<1].len_r+arr1[rt<<1|1].len_l,Max(arr1[rt].len_l,arr1[rt].len_r)));

    arr0[rt].len_l = arr0[rt<<1].len_l;
    if(arr0[rt].len_l==mid-l+1) arr0[rt].len_l+=arr0[rt<<1|1].len_l;
    arr0[rt].len_r = arr0[rt<<1|1].len_r;
    if(arr0[rt].len_r==r-mid) arr0[rt].len_r+=arr0[rt<<1].len_r;
    arr0[rt].len = Max(arr0[rt<<1].len,arr0[rt<<1|1].len);
    arr0[rt].len = Max(arr0[rt].len,Max(arr0[rt<<1].len_r+arr0[rt<<1|1].len_l,Max(arr0[rt].len_l,arr0[rt].len_r)));
}
void SWAP(int rt)
{
    int len_l = arr1[rt].len_l;
    int len_r = arr1[rt].len_r;
    int len = arr1[rt].len;
    arr1[rt].len_l = arr0[rt].len_l;
    arr1[rt].len_r = arr0[rt].len_r;
    arr1[rt].len = arr0[rt].len;
    arr0[rt].len_l = len_l;
    arr0[rt].len_r = len_r;
    arr0[rt].len = len;
}
void down(int rt,int l,int r)
{
    if(arr1[rt].down)
    {
        arr1[rt].down^=1;
        arr1[rt<<1].down^=1;
        arr1[rt<<1|1].down^=1;
        SWAP(rt<<1);
        SWAP(rt<<1|1);
    }
}
void build(int rt,int l,int r)
{
    arr1[rt].len_l = arr1[rt].len_r = arr1[rt].down = arr1[rt].len = 0;
    arr0[rt].len_l = arr0[rt].len_r = arr0[rt].down = arr0[rt].len = 0;
    if(l==r)
    {
        scanf("%d",&arr1[rt].len);
        if(arr1[rt].len)
        {
            arr1[rt].len_l = arr1[rt].len_r = 1;
        }
        else
        {
            arr0[rt].len_l = arr0[rt].len_r = arr0[rt].len = 1;
        }
        return ;
    }
    build(rt<<1,l,mid);
    build(rt<<1|1,mid+1,r);
    up(rt,l,r);
}
void update(int rt,int l,int r,int x,int y)
{
    if(x<=l&&r<=y)
    {
        arr1[rt].down^=1;
        SWAP(rt);
        return ;
    }
    down(rt,l,r);
    if(x<=mid) update(rt<<1,l,mid,x,y);
    if(mid<y) update(rt<<1|1,mid+1,r,x,y);
    up(rt,l,r);
}
node query(int rt,int l,int r,int x,int y)
{
    if(x<=l&&r<=y)
        return arr1[rt];
    down(rt,l,r);
    if(x<=mid&&y>mid)
    {
        node tmp1 = query(rt<<1,l,mid,x,y);
        node tmp2 = query(rt<<1|1,mid+1,r,x,y);
        node ans;
        ans.len_l = tmp1.len_l,ans.len_r = tmp2.len_r;
        if(ans.len_l==mid-l+1) ans.len_l+=tmp2.len_l;
        if(ans.len_r==r-mid) ans.len_r += tmp1.len_r;
        ans.len = Max(tmp1.len,tmp2.len);
        ans.len = Max(ans.len,Max(tmp1.len_r+tmp2.len_l,Max(ans.len_l,ans.len_r)));
        return ans;
    }
    else if(x<=mid)
    {
        return query(rt<<1,l,mid,x,y);
    }
    else if(x>mid)
    {
        return query(rt<<1|1,mid+1,r,x,y);
    }
}
int main()
{
    //ios::sync_with_stdio(false);
    //freopen("a.txt","r",stdin);
    //freopen("b.txt","w",stdout);
    int n,Q,opt,x,y;
    while(scanf("%d",&n)==1)
    {
        build(1,1,n);
        scanf("%d",&Q);
        while(Q--)
        {
            scanf("%d%d%d",&opt,&x,&y);
            if(opt==1)
            {
                update(1,1,n,x,y);
            }
            else
            {
                printf("%d\n",query(1,1,n,x,y).len);
            }
        }
    }
    //fclose(stdin);
    //fclose(stdout);
    //cout << "time: " << (long long)clock() * 1000 / CLOCKS_PER_SEC << " ms" << endl;
    return 0;
}

The second

#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <cmath>
#include <map>
#include <stack>
#include <set>
#include <sstream>
#include <vector>
#include <stdlib.h>
#include <algorithm>
using namespace std;

#define dbg(x) cout<<#x<<" = "<< (x)<< endl
#define dbg2(x1,x2) cout<<#x1<<" = "<<x1<<" "<<#x2<<" = "<<x2<<endl
#define dbg3(x1,x2,x3) cout<<#x1<<" = "<<x1<<" "<<#x2<<" = "<<x2<<" "<<#x3<<" = "<<x3<<endl
#define max3(a,b,c) max(a,max(b,c))
#define min3(a,b,c) min(a,min(b,c))
#define lc (rt<<1)
#define rc (rt<<11)
#define mid ((l+r)>>1)

typedef pair<int,int> pll;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const int _inf = 0xc0c0c0c0;
const ll INF = 0x3f3f3f3f3f3f3f3f;
const ll _INF = 0xc0c0c0c0c0c0c0c0;
const ll mod =  (int)1e9+7;

ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
ll ksm(ll a,ll b,ll mod){int ans=1;while(b){if(b&1) ans=(ans*a)%mod;a=(a*a)%mod;b>>=1;}return ans;}
ll inv2(ll a,ll mod){return ksm(a,mod-2,mod);}
int Max(int a,int b)
{
    if(a>b) return a;
    return b;
}
int Min(int a,int b)
{
    if(a<b) return a;
    return b;
}
void Swap(int &x,int &y)
{
    int t = x;
    x = y;
    y = t;
}
const int MAX_N = 100025;
struct node
{
    int down,ls0,rs0,ls1,rs1,ms0,ms1;
}arr[MAX_N<<2];
void up(int rt,int l,int r)
{
    arr[rt].ls1 = arr[rt<<1].ls1;
    arr[rt].rs1 = arr[rt<<1|1].rs1;
    if(arr[rt].ls1==mid-l+1) arr[rt].ls1+=arr[rt<<1|1].ls1;
    if(arr[rt].rs1==r-mid) arr[rt].rs1+=arr[rt<<1].rs1;
    arr[rt].ms1 = Max(arr[rt<<1].ms1,arr[rt<<1|1].ms1);
    arr[rt].ms1 = Max(arr[rt].ms1,Max(Max(arr[rt].ls1,arr[rt].rs1),arr[rt<<1].rs1+arr[rt<<1|1].ls1));

    arr[rt].ls0 = arr[rt<<1].ls0;
    arr[rt].rs0 = arr[rt<<1|1].rs0;
    if(arr[rt].ls0==mid-l+1) arr[rt].ls0+=arr[rt<<1|1].ls0;
    if(arr[rt].rs0==r-mid) arr[rt].rs0+=arr[rt<<1].rs0;
    arr[rt].ms0 = Max(arr[rt<<1].ms0,arr[rt<<1|1].ms0);
    arr[rt].ms0 = Max(arr[rt].ms0,Max(Max(arr[rt].ls0,arr[rt].rs0),arr[rt<<1].rs0+arr[rt<<1|1].ls0));
}
void SWAP(int rt)
{
    Swap(arr[rt].ls1,arr[rt].ls0);
    Swap(arr[rt].rs1,arr[rt].rs0);
    Swap(arr[rt].ms1,arr[rt].ms0);
}
void down(int rt,int l,int r)
{
    if(arr[rt].down)
    {
        arr[rt].down^=1;
        arr[rt<<1].down^=1;
        arr[rt<<1|1].down^=1;
        SWAP(rt<<1),SWAP(rt<<1|1);
    }
}
void build(int rt,int l,int r)
{
    arr[rt].down = arr[rt].ls0 = arr[rt].ls1=arr[rt].ms0=arr[rt].ms1=arr[rt].ms0 =arr[rt].rs0=arr[rt].rs1= 0;
    if(l==r)
    {
        int v;
        scanf("%d",&v);
        if(v)
        {
            arr[rt].ls1 = arr[rt].rs1 = arr[rt].ms1 = 1;
        }
        else
        {
            arr[rt].ls0 = arr[rt].rs0 = arr[rt].ms0 = 1;
        }
        return ;
    }
    build(rt<<1,l,mid);
    build(rt<<1|1,mid+1,r);
    up(rt,l,r);
}
void update(int rt,int l,int r,int x,int y)
{
    if(x<=l&&r<=y)
    {
        arr[rt].down^=1;
        SWAP(rt);
        return ;
    }
    down(rt,l,r);
    if(x<=mid) update(rt<<1,l,mid,x,y);
    if(mid<y) update(rt<<1|1,mid+1,r,x,y);
    up(rt,l,r);
}
node query(int rt,int l ,int r,int x,int y)
{
    if(x<=l&&r<=y)
    {
        return arr[rt];
    }
    down(rt,l,r);
    if(x<=mid&&y>mid)
    {
        node tmp1 = query(rt<<1,l,mid,x,y);
        node tmp2 = query(rt<<1|1,mid+1,r,x,y);
        node ans;
        ans.ls1 = tmp1.ls1,ans.ls0 = tmp1.ls0;
        ans.rs0 = tmp2.rs0,ans.rs1 = tmp2.rs1;
        if(ans.ls1 == mid-l+1) ans.ls1+=tmp2.ls1;
        if(ans.ls0==mid-l+1) ans.ls0+=tmp2.ls0;
        if(ans.rs0==r-mid) ans.rs0+=tmp1.rs0;
        if(ans.rs1==r-mid) ans.rs1 += tmp1.rs1;
        ans.ms1 = Max(Max(Max(tmp1.ms1,tmp2.ms1),Max(ans.ls1,ans.rs1)),tmp1.rs1+tmp2.ls1);
        return ans;
    }
    else if(x<=mid)
    {
        return query(rt<<1,l,mid,x,y);
    }
    else if(x>mid)
    {
        return query(rt<<1|1,mid+1,r,x,y);
    }
}
int main()
{
    //ios::sync_with_stdio(false);
    //freopen("a.txt","r",stdin);
    //freopen("b.txt","w",stdout);
    int n,Q,opt,x,y;
    while(scanf("%d",&n)==1)
    {
        build(1,1,n);
        scanf("%d",&Q);
        while(Q--)
        {
            scanf("%d%d%d",&opt,&x,&y);
            if(opt==0)
            {
                printf("%d\n",query(1,1,n,x,y).ms1);
            }
            else
            {
                update(1,1,n,x,y);
            }
        }
    }
    //fclose(stdin);
    //fclose(stdout);
    //cout << "time: " << (long long)clock() * 1000 / CLOCKS_PER_SEC << " ms" << endl;
    return 0;
}
HDU - 3397 Sequence operation (线段树，区间修改，亦或，查询，以及最长连续的1)
Top_xiao的博客
08-11 480
有5个操作， 0  区间全部置为0 1 区间全部置为1 2 区间的值取反，1 变0 ，0变1， 3 求区间1 的个数。 4 求区间连续最长的1.   思路： lazy标记， 有 -1,0,1,2, 四种标记， -1 是什么都没有， 0,1 算是一种操作，区间修改， 2 是一种操作，亦或。   因为亦或这个操作。我们存一下1 的所有数据，0的所有数据，便于以后交换。 我们...
hdu 3397 Sequence operation 线段树 区间和 连续1的个数
08-13 539
Sequence operation Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 6032    Accepted Submission(s): 1784 Problem Description lxhgww got
G - Tunnel Warfare HDU - 1540（线段树区间合并，最长连续01）
tomjobs的博客
09-23 269
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 t...
线段树-区间最大连续1 NKOJ2753
weixin_30394981的博客
01-04 161
结构体 node 中 l 表示左界，r 表示右界， cons_l 从左开始最大连续1， cons_r ...，max 区间最大连续1 代码 1 #include <stdio.h> 2 #include <queue> 3 #include <algorithm> 4 5 using namespace std; 6...
Hotel(线段树区间合并-维护最长连续的1)
代码笔记本
11-12 327
https://www.luogu.com.cn/problem/P2894 火山经营着一个停车场，假设的停车场有N车位（编号1-N）都在一条线上，最初所有车位都没停车。经常有人来定车位， 他要定连续的k(1 ≤ k ≤ N)个车位。火山要确定是否能够满足客人的要求，如果能，他要将这k个连续的车位安排在编 号最小的地方停下。若不能，则客人不停在火山的停车场。在某一时间，有些车会被车主开走了。火山的停车场很大， 火山想让学弟学妹写个程序帮助他。 Input 第1行输入N 和 M。N是车位个..
讲课专用——线段树——最长连续空位
weixin_30325487的博客
07-05 298
题目链接：https://www.luogu.org/problemnew/show/P2894 题意： 酒店n个房间，m个操作：入住或退房 如果操作为入住，同一批客人安排的房间号必须连续 操作1：有x个客人要入住，输出满足条件的最小的房间编号，若不满足条件输出0 操作2：房间为[x,y]的客人要退房 题解： 如果你会了第一题（BSS），这题就简单了 题意转化：询问...
【题解】「HDU1166」敌兵布阵(线段树)
01-20
(1)Add(1) Add(1)Add iii jjj，iii和jjj为正整数,表示第iii个营地增加jjj个人（jjj不超过303030） (2)Sub(2)Sub(2)Sub iii jjj ，iii和jjj为正整数,表示第iii个营地减少jjj个人（jjj不超过303030）; (3)Query(3)...
【hdu5306】Gorgeous Sequence 线段树区间最值操作-附件资源
03-05
【hdu5306】Gorgeous Sequence 线段树区间最值操作-附件资源
hdu 1166线段树
07-02
标题与描述均提到了“hdu 1166线段树”，这表明文章的核心是关于线段树在解决特定问题中的应用。线段树是一种数据结构，主要用于处理区间查询和更新操作，尤其是在大规模数据集上。在本例中，通过分析给定的部分代码...
LeetCode 1004.最长连续1的个数
weixin_30270561的博客
07-08 547
给定一个由若干 0 和 1 组成的数组 A，我们最多可以将 K 个值从 0 变成 1 。返回仅包含 1 的最长（连续）子数组的长度。示例 1：输入：A = [1,1,1,0,0,0,1,1,1,1,0], K = 2输出：6解释： [1,1,1,0,0,1,1,1,1,1,1]粗体数字从 0 翻转到 1，最长的子数组长度为 6。示例 2：输入：A = [0,0,1,1,0,0,1,1,1,0,1...
线段树区间合并（单点更新+查找包含该位置的最长连续全1串）
black_horse2018的博客
05-03 322
Tunnel Warfare Time Limit: 4000/2000 MS (Java/Others)Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 15230Accepted Submission(s): 6019 Problem Description ...
hdu3911——Black And White (线段树区间合并)
weixin_30536513的博客
05-16 167
Time limit3000 msMemory limit32768 kBThere are a bunch of stones on the beach; Stone color is white or black. Little Sheep has a magic brush, she can change the color of a continuous ...
【LeetCode】最大连续1的个数Ⅰ~Ⅲ
像写诗一样优雅地写代码~
01-19 4213
【LeetCode】最大连续1的个数Ⅰ~Ⅲ 最大连续1的个数★ LeetCode 485. 最大连续1的个数 【题目】给定一个二进制数组， 计算其中最大连续1的个数。 【示例】 输入: [1,1,0,1,1,1] 输出: 3 解释: 开头的两位和最后的三位都是连续1，所以最大连续1的个数是 3. 【解题思路】 class Solution { public int findMaxConsecutiveOnes(int[] nums) { int count = 0, max = 0
最大连续1的个数
weixin_41777654的博客
06-13 270
给定一个二进制数组 nums ， 计算其中最大连续 1 的个数。示例 1：输入：nums = [1,1,0,1,1,1] 输出：3 解释：开头的两位和最后的三位都是连续 1 ，所以最大连续 1 的个数是 3. 示例 2:输入：nums = [1,0,1,1,0,1] 输出：2作者：力扣 (LeetCode) 链接：https://leetcode.cn/leetbook/read/array-and-string/cd71t/ 来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非
LeetCode-485. 最大连续1的个数
听雪楼
11-01 1726
题目 给定一个二进制数组， 计算其中最大连续1的个数。 示例 1: 输入: [1,1,0,1,1,1] 输出: 3 解释: 开头的两位和最后的三位都是连续1，所以最大连续1的个数是 3. 注意： 输入的数组只包含 0 和1。 输入数组的长度是正整数，且不超过 10,000。 解题 使用一个变量max记录连续1的最大个数 遍历数次, 同时使用一个临时数组, 记录遍历过程中连续1的最大个数, 当...
Tunnel Warfare(线段树)最长连续区间
weixin_44554979的博客
08-24 314
题目（http://acm.hdu.edu.cn/showproblem.php?pid=1540） During the War of Resistance Against Japan, tunnel warfare was carried out extensively in the vast areas of north China Plain. Generally speaking, v...
【Leetcode】最大连续1的个数
小朱小朱绝不认输的博客
07-01 950
leetcode最大连续1的个数算法汇总
线段树维护区间最长连续0的长度
lalalafloat的博客
03-09 881
原理 本身区间最长连续0之间不可以进行区间加法操作，违背线段树基本的运算。但是容易想到两个区间合并产生的最值变化，主要由Lson的右端连续0长度加上Rson的左端连续0长度引起。即 tree[x].ma=max(tree[Lson].R0+tree[Rson].L0,max(tree[Lson].ma,tree[Rson].ma)); 因此我们可以考虑维护一个区间的左端连续0个数和右端连续0个数。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值