[SHOI 2015] 脑洞治疗仪

[题目链接]

https://www.lydsy.com/JudgeOnline/problem.php?id=4592

[算法]

对于操作1 ， 我们首先查询区间[l0 , r0]中有多少个1 ， 然后二分求出最大的x(x <= r1)使得[l1 , x]中0的个数 <= [l0 , r0]中1的个数

对于操作2 ， 对于一段区间[l , r] , 我们将它分成[l , mid]和[mid + 1 , r]两个子区间 ， 那么 ， 最长连续的0的个数有三种情况 :

1. 在[l , mid]中 2. 在[mid + 1 , r]中 3. mid向前延伸最多的0的个数 + (mid + 1)向后延伸最多的0的个数

线段树维护即可

时间复杂度 : O(NlogN ^ 2)

[代码]

#include<bits/stdc++.h>
using namespace std;
#define MAXN 200010
typedef long long ll;
typedef long double ld;
const int inf = 1e9;

int n , m;

template <typename T> inline void chkmax(T &x , T y) { x = max(x , y); }
template <typename T> inline void chkmin(T &x , T y) { x = min(x , y); }
template <typename T> inline void read(T &x)
{
    T f = ; x  = ;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
    for (; isdigit(c); c = getchar()) x = (x << ) + (x << ) + c - '';
    x *= f;
}

struct Segment_Tree
{
    struct Node
    {
        int l , r;
        int lm0 , rm0 , value , cnt;
        int tag;
    } a[MAXN << ];
    inline void build(int index , int l , int r)
    {
        a[index].l = l , a[index].r = r;
        a[index].cnt = r - l + ;
        a[index].tag = -;
        if (l == r) return;
        int mid = (l + r) >> ;
        build(index <<  , l , mid);
        build(index <<  |  , mid +  , r);
    }
    inline void update(int x)
    {
        int l = a[x].l , r = a[x].r;
        int mid = (l + r) >> ;
        a[x].cnt = a[x << ].cnt + a[x <<  | ].cnt;
        if (a[x << ].lm0 == mid - l + ) a[x].lm0 = mid - l +  + a[x <<  | ].lm0;
        else a[x].lm0 = a[x << ].lm0;
        if (a[x <<  | ].rm0 == r - mid) a[x].rm0 = r - mid + a[x << ].rm0;
        else a[x].rm0 = a[x <<  | ].rm0;
        a[x].value = max(a[x << ].value , a[x <<  | ].value);
        chkmax(a[x].value , a[x << ].rm0 + a[x <<  | ].lm0);
    }
    inline void pushdown(int index)
    {
        int l = a[index].l , r = a[index].r;
        int mid = (l + r) >> ;
        if (l == r) return;
        if (a[index].tag == )
        {
            a[index << ].cnt = a[index <<  | ].cnt = ;
            a[index << ].value = mid - l + ;
            a[index <<  | ].value = r - mid;
            a[index << ].lm0 = a[index << ].rm0 = mid - l + ;
            a[index <<  | ].lm0 = a[index <<  | ].rm0 = r - mid;
            a[index << ].tag = a[index <<  | ].tag = a[index].tag;
            a[index].tag = -;
        }
        if (a[index].tag == )
        {
            a[index << ].cnt = mid - l + ;
            a[index <<  | ].cnt = r - mid;
            a[index << ].value = a[index <<  | ].value = ;
            a[index << ].lm0 = a[index << ].rm0 = ;
            a[index <<  | ].lm0 = a[index <<  | ].rm0 = ;
            a[index << ].tag = a[index <<  | ].tag = a[index].tag;
            a[index].tag = -;
        }
    }
    inline void modify(int index , int l , int r)
    {
        if (a[index].l == l && a[index].r == r)
        {
            a[index].cnt = ;
            a[index].lm0 = a[index].rm0 = r - l + ;
            a[index].value = r - l + ;
            a[index].tag = ;
            return;
        }
        pushdown(index);
        int mid = (a[index].l + a[index].r) >> ;
        if (mid >= r) modify(index <<  , l , r);
        else if (mid +  <= l) modify(index <<  |  , l , r);
        else
        {
            modify(index <<  , l , mid);
            modify(index <<  |  , mid +  , r);
        }
        update(index);
    }
    inline int queryA(int index , int l , int r)
    {
            if (a[index].l == l && a[index].r == r)
                    return a[index].cnt;
            pushdown(index);
            int mid = (a[index].l + a[index].r) >> ;
            if (mid >= r) return queryA(index <<  , l , r);
            else if (mid +  <= l) return queryA(index <<  |  , l , r);
            else return queryA(index <<  , l , mid) + queryA(index <<  |  , mid +  , r);
        }
        inline int queryB(int index , int l , int r)
    {
        if (a[index].l == l && a[index].r == r)
            return a[index].value;
        pushdown(index);
        int mid = (a[index].l + a[index].r) >> ;
        if (mid >= r) return queryB(index <<  , l , r);
        else if (mid +  <= l) return queryB(index <<  |  , l , r);
        {
                      int ret = max(queryB(index <<  , l , mid) , queryB(index <<  |  , mid +  , r));
            chkmax(ret , min(mid - l +  , a[index << ].rm0) + min(r - mid , a[index <<  | ].lm0));
            return ret;
        }
    }
    inline void change(int index , int l , int r)
    {
            if (l > r) return;
                 if (a[index].l == l && a[index].r == r)
                 {
                         a[index].cnt = r - l + ;
                        a[index].lm0 = a[index].rm0 = a[index].value = ;
                        a[index].tag = ;
                        return;
                }
                pushdown(index);
                int mid = (a[index].l + a[index].r) >> ;
                if (mid >= r) change(index <<  , l , r);
                else if (mid +  <= l) change(index <<  |  , l , r);
                else
                {
                        change(index <<  , l , mid);
                        change(index <<  |  , mid +  , r);
                }
                update(index);
    }
} SGT;

int main()
{

    read(n); read(m);
    SGT.build( ,  , n);
    for (int i = ; i <= m; i++)
    {
        int type;
        read(type);
        if (type == )
        {
            int x , y;
            read(x); read(y);
            SGT.modify( , x , y);
        } else if (type == )
        {
            int l0 , r0 , l1 , r1;
            read(l0); read(r0); read(l1); read(r1);
            int cnt = SGT.queryA( , l0 , r0);
            SGT.modify( , l0 , r0);
            int l = l1 , r = r1 , loc = ;
            while (l <= r)
            {
                    int mid = (l + r) >> ;
                    if ((mid - l1 + ) - SGT.queryA( , l1 , mid) <= cnt)
                    {
                            loc = mid;
                            l = mid + ;
                                } else r = mid - ;
                        }
            SGT.change( , l1 , loc);
        } else
        {
            int l , r;
            read(l); read(r);
            printf("%d\n" , SGT.queryB( , l , r));
        }
    }

    return ;
}