poj1823线段树

题意：

有人要住旅馆，然后住在一些连续的房间里；

那么让你求空闲的连续的旅馆的最大长度；

理解：

此题认真想想应该就是线段树了；

然后合并的是区间，而不是单独的值；

合并区间就有点麻烦了；

主要就是两个区间合并的时候要注意中间是否可以再组成一个区间；‘

做法就是记录此区间的两端没有住人的两端；

然后将此区间的最大值求出来；

之后向上合并；

注意合并时要判断中间是否可以连接起来；

代码如下：（线段树就是太难写了，不过思路清晰就好写了）

#include <cstdio>

#include <algorithm>
#include <vector>

using namespace std;

#define P pair<int, int>
#define x first
#define y second

struct node
{
    int len;
    int flag;
    P lt, rt; //左右两端的空闲区间
};

node tree[16000 * 5 + 10];
int up[16000 * 5 + 10];

node build(int l, int r, int rx)
{
    if (l == r)
    {
        tree[rx].len = 1;
        tree[rx].flag = 0;
        tree[rx].lt = tree[rx].rt = P(l, r);
        return tree[rx];
    }

    node n1 = build(l, (l + r) / 2, rx * 2);
    node n2 = build((l + r) / 2 + 1, r, rx * 2 + 1);
    tree[rx].len = n1.len + n2.len;
    tree[rx].flag = 0;
    tree[rx].lt = tree[rx].rt = P(n1.lt.x, n2.rt.y);

    return tree[rx];
}

void push_down(int l, int r, int rx)
{
    if (l != r)
    {
        up[rx * 2] = up[rx];
        up[rx * 2 + 1] = up[rx];
        if (up[rx] == 1)
        {
            tree[rx * 2].len = tree[rx * 2 + 1].len = 0;

            tree[rx * 2].flag = tree[rx * 2 + 1].flag = 1;

            tree[rx * 2].lt
                = tree[rx * 2].rt
                = tree[rx * 2 + 1].lt
                = tree[rx * 2 + 1].rt
                = P(-1, -1);
        }
        else
        {
            tree[rx * 2].len
                = (l + r) / 2 - l + 1;
            tree[rx * 2 + 1].len
                = r - (l + r) / 2 - 1 + 1;

            tree[rx * 2].flag = tree[rx * 2 + 1].flag = 0;

            tree[rx * 2].lt
                = tree[rx * 2].rt
                = P(l, (l + r) / 2);
            tree[rx * 2 + 1].lt
                = tree[rx * 2 + 1].rt
                = P((l + r) / 2 + 1, r);
        }
    }
    up[rx] = 0;
}

void update(int l, int r, int L, int R, int rx, int num)
{
    if (L > r || R < l) return ;

    if (L >= l && R <= r)
    {
        up[rx] = (num == 0 ? -1 : 1);
        if (num == 0)
        {
            tree[rx].len = R - L + 1;
            tree[rx].flag = 0;
            tree[rx].lt = tree[rx].rt = P(L, R);
        }
        else
        {
            tree[rx].len = 0;
            tree[rx].flag = 1;
            tree[rx].lt = tree[rx].rt = P(-1, -1);
        }
        return ;
    }

    if (up[rx])
    {
        push_down(L, R, rx);  //开始的时候push_down放错位置了，结果超时，坑
    }

    update(l, r, L, (L + R) / 2, rx * 2, num);
    node n1 = tree[rx * 2];
    update(l, r, (L + R) / 2 + 1, R, rx * 2 + 1, num);
    node n2 = tree[rx * 2 + 1];

    if (n1.flag != n2.flag)
    {
        tree[rx] = (n1.flag == 0 ? n1 : n2);
        return ;
    }

    if (n1.flag == n2.flag && n1.flag == 1)
    {
        tree[rx].len = 0;
        tree[rx].flag = 1;
        tree[rx].lt = tree[rx].rt = P(-1, -1);
        return ;
    }

    if (n1.rt.y + 1 == n2.lt.x)
    {
        tree[rx].len = max(n1.len, max(n2.len, n2.lt.y - n1.rt.x + 1));
        tree[rx].flag = 0;
        if (n1.lt.y < n1.rt.x)
        {
            tree[rx].lt = n1.lt;
        }
        else tree[rx].lt = P(n1.rt.x, n2.lt.y);

        if (n2.lt.y < n2.rt.x)
        {
            tree[rx].rt = n2.rt;
        }
        else tree[rx].rt = P(n1.rt.x, n2.lt.y);
        return ;
    }

    tree[rx].len = max(n1.len, n2.len);
    tree[rx].flag = 0;
    tree[rx].lt = n1.lt;
    tree[rx].rt = n2.rt;
    return ;
}

int main()
{
    int n, p;
    scanf("%d%d", &n, &p);
    build(1, n, 1);
    for (int i = 0; i < p; ++i)
    {
        int num;
        scanf("%d", &num);
        if (num == 3)
        {
            printf("%d\n", tree[1].len);
        }
        else if (num == 1)
        {
            int num1, num2;
            scanf("%d%d", &num1, &num2);
            update(num1, num1 + num2 - 1, 1, n, 1, 1);
        }
        else
        {
            int num1, num2;
            scanf("%d%d", &num1, &num2);
            update(num1, num1 + num2 - 1, 1, n, 1, 0);
        }
    }

    return 0;
}