HDU 3308【线段树-query：区间最长单调上升序列，update：结点更新，区间合并】

最新推荐文章于 2021-08-24 15:00:57 发布

lyt9469

最新推荐文章于 2021-08-24 15:00:57 发布

阅读量365

点赞数

CC 4.0 BY-SA版权

分类专栏：数据结构文章标签： tree query output cmd each struct

本文链接：https://blog.youkuaiyun.com/lyt9469/article/details/6824633

数据结构专栏收录该内容

9 篇文章

订阅专栏

本文介绍了一个涉及最长连续递增子序列(LCIS)的问题，并提供了一种使用分段树的数据结构来高效处理更新和查询操作的方法。通过示例输入和输出展示了如何在一系列更新和查询操作中找到指定范围内的LCIS长度。

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

LCIS

Time Limit: 6000/2000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 952 Accepted Submission(s): 447

Problem Description

Given n integers.
You have two operations:
U A B: replace the Ath number by B. (index counting from 0)
Q A B: output the length of the longest consecutive increasing subsequence (LCIS) in [a, b].

Input

T in the first line, indicating the case number.
Each case starts with two integers n , m(0<n,m<=10 ⁵).
The next line has n integers(0<=val<=10 ⁵).
The next m lines each has an operation:
U A B(0<=A,n , 0<=B=10 ⁵)
OR
Q A B(0<=A<=B< n).

Output

For each Q, output the answer.

Sample Input

  
   1
10 10
7 7 3 3 5 9 9 8 1 8 
Q 6 6
U 3 4
Q 0 1
Q 0 5
Q 4 7
Q 3 5
Q 0 2
Q 4 6
U 6 10
Q 0 9

Sample Output

Author

shǎ崽

Source

HDOJ Monthly Contest – 2010.02.06

Recommend

wxl

#include <cstdlib>
#include <cstdio>
#include <iostream>
using namespace std;
const int MAXN = 100000;
struct node {
    int s;
    int e;
    int ml;
    int mr;
    int ma;
} tree[MAXN * 4 + 10];
int num[MAXN + 10];
inline void update(int i) {
    int left = i << 1;
    int right = (i << 1) | 1;
    tree[i].ml = tree[left].ml;
    tree[i].mr = tree[right].mr;
    tree[i].ma = 0;
    int mid = (tree[i].s + tree[i].e) >> 1;
    if (num[mid] < num[mid + 1]) {
        if (tree[i].ml == tree[left].e - tree[left].s + 1)
            tree[i].ml += tree[right].ml;
        if (tree[i].mr == tree[right].e - tree[right].s + 1)
            tree[i].mr += tree[left].mr;
        tree[i].ma = tree[left].mr + tree[right].ml;
    }
    tree[i].ma = max(tree[i].ma, max(tree[left].ma, tree[right].ma));
}
void init(int i, int s, int e) {
    tree[i].s = s;
    tree[i].e = e;
    if (s < e) {
        int mid = (s + e) >> 1;
        init(i << 1, s, mid);
        init((i << 1) | 1, mid + 1, e);
        update(i);
    } else {
        tree[i].ml = tree[i].mr = tree[i].ma = 1;
    }
}
void modify(int i, int s, int e, int val) {
    if (tree[i].s == s && tree[i].e == e) {
        num[tree[i].s] = val;
        return;
    }
    if (tree[i].s < tree[i].e) {
        int mid = (tree[i].s + tree[i].e) >> 1;
        if (e <= mid)
            modify(i << 1, s, e, val);
        else
            modify((i << 1) | 1, s, e, val);
        update(i);
    }
    return;
}
int query(int i, int s, int e) {
    if (s<=tree[i].s && tree[i].e <= e) {
        return tree[i].ma;
    }

  //  if (tree[i].s < tree[i].e) {
        int mid = (tree[i].s + tree[i].e) >> 1;
        if (e <= mid)
            return query(i << 1, s, e);
        else if (s > mid)
            return query((i << 1) | 1, s, e);
        else {
            if (num[mid] < num[mid + 1]) {
                int tmp = min(mid - s + 1, tree[i << 1].mr) + min(e - mid, tree[(i << 1) | 1].ml);
                return max(tmp, max(query(i << 1, s, e), query((i << 1) + 1, s, e)));
            }
            return max(query(i << 1, s, e), query((i << 1) + 1, s, e));
        }
   // }
}
int main(int argc, char** argv) {
    int T;
    scanf("%d", &T);
    while (T--) {
        int n, m;
        scanf("%d%d", &n, &m);
        int i(0);
        int tmp;
        for (i = 1; i <= n; ++i) {
            scanf("%d", num + i);
        }
        init(1, 1, n);
        char cmd[2];
        int a, b;
        while (m--) {
            scanf("%s", cmd);
            if (cmd[0] == 'Q') {
                scanf("%d%d", &a, &b);
                printf("%d\n", query(1, a + 1, b + 1));
            } else {
                scanf("%d%d", &a, &b);
                modify(1, a + 1, a + 1, b);
            }
        }
    }
    system("pause");
    return 0;
}