hdu 3308(区间合并)

最新推荐文章于 2020-02-25 17:33:09 发布

原创最新推荐文章于 2020-02-25 17:33:09 发布 · 417 阅读

0 ·

CC 4.0 BY-SA版权

ACM-线段树专栏收录该内容

54 篇文章

订阅专栏

本文介绍了一种利用线段树解决最长连续上升子序列问题的方法。通过维护每个区间内的最长上升子序列长度、从左右两端延伸的上升序列长度及端点值，实现了对序列的操作与查询。特别地，在合并区间时考虑到左右端点值的关系来更新整个区间的最长上升子序列长度。

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

题意：有一个长度为n的序列，两种操作，U a b表示把位置a上数字替换为b，Q a b输出区间[a,b]内最长的连续上升子序列长度。
题解：之前做过类似的，线段树维护每个区间最长上升子序列长度，从左端点延伸的上升序列长度，从右端点延伸的上升序列的长度，还有左右端点的值。在合并区间时注意左子区间的右端点小于右子区间的左端点时需要更新整个区间的最长上升子序列长度。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 100005;
struct Tree {
    int len, liml, limr;
    int lv, rv;
}tree[N << 2];
int n, m, A[N];

void pushup(int k, int left, int right) {
    int mid = (left + right) / 2;
    tree[k].lv = tree[k * 2].lv;
    tree[k].rv = tree[k * 2 + 1].rv;
    tree[k].liml = tree[k * 2].liml;
    tree[k].limr = tree[k * 2 + 1].limr;
    tree[k].len = max(tree[k * 2].len, tree[k * 2 + 1].len);
    if (tree[k * 2].rv < tree[k * 2 + 1].lv) {
        if (tree[k * 2].liml == mid - left + 1)
            tree[k].liml += tree[k * 2 + 1].liml;
        if (tree[k * 2 + 1].limr == right - mid)
            tree[k].limr += tree[k * 2].limr;
        tree[k].len = max(tree[k].len, tree[k * 2].limr + tree[k * 2 + 1].liml);
    }
    tree[k].len = max(tree[k].len, max(tree[k].liml, tree[k].limr));
}

void build(int k, int left, int right) {
    if (left == right) {
        tree[k].rv = tree[k].lv = A[left];
        tree[k].liml = tree[k].limr = tree[k].len = 1;
        return;
    }
    int mid = (left + right) / 2;
    build(k * 2, left, mid);
    build(k * 2 + 1, mid + 1, right);
    pushup(k, left, right);
}

void modify(int k, int left, int right, int pos, int v) {
    if (left == right) {
        tree[k].lv = tree[k].rv = v;
        return;
    }
    int mid = (left + right) / 2;
    if (pos <= mid)
        modify(k * 2, left, mid, pos, v);
    else
        modify(k * 2 + 1, mid + 1, right, pos, v);
    pushup(k, left, right);
}

int query(int k, int left, int right, int l, int r) {
    if (l <= left && right <= r)
        return tree[k].len;
    int mid = (left + right) / 2;
    if (r <= mid)
        return query(k * 2, left, mid, l, r);
    if (l > mid)
        return query(k * 2 + 1, mid + 1, right, l, r);
    int res = max(query(k * 2, left, mid, l, mid), query(k * 2 + 1, mid + 1, right, mid + 1, r));
    if (tree[k * 2].rv < tree[k * 2 + 1].lv) {
        int temp1 = min(mid - l + 1, tree[k * 2].limr);
        int temp2 = min(r - mid, tree[k * 2 + 1].liml);
        res = max(res, temp1 + temp2);
    }
    return res;
}

int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        scanf("%d%d", &n, &m);
        for (int i = 0; i < n; i++)
            scanf("%d", &A[i]);
        build(1, 0, n - 1);
        char op[5];
        int a, b;
        while (m--) {
            scanf("%s%d%d", op, &a, &b);
            if (op[0] == 'U')
                modify(1, 0, n - 1, a, b);
            else
                printf("%d\n", query(1, 0, n - 1, a, b));
        }
    }
    return 0;
}