Time Limit: 3000/1000MS (Java/Others)     Memory Limit: 65535/65535KB (Java/Others)
Submit 
Status

For a sequence S1,S2,⋯,SNS1,S2,⋯,SN,
and a pair of integers (i,j)(i,j),
if 1≤i≤j≤N1≤i≤j≤N and Si<Si+1<Si+2<⋯<Sj−1<SjSi<Si+1<Si+2<⋯<Sj−1<Sj,
then the sequence Si,Si+1,⋯,SjSi,Si+1,⋯,Sj is
CIS(Continuous Increasing Subsequence). The longest CIS of
a sequence is called the LCIS (Longest Continuous Increasing Subsequence).

In this problem, we will give you a sequence first, and then some add operations
and some query operations. An add operation adds a value to each member
in a specified interval. For a query operation, you should output the length of the LCIS of a specified interval.

Input

The first line of the input is an integer TT,
which stands for the number of test cases you need to solve.

Every test case begins with two integers NN, QQ,
where NN is
the size of the sequence, and QQ is
the number of queries. S1,S2,⋯,SNS1,S2,⋯,SN are
specified on the next line, and then QQqueries
follow. Every query begins with a character a or qa is
followed by three integers LL, RR, VV,
meaning that add VV to
members in the interval [L,R][L,R] (including LL, RR),
and q is followed by two integers LL, RR,
meaning that you should output the length of the LCIS of interval [L,R][L,R].

T≤10T≤10;

1≤N,Q≤1000001≤N,Q≤100000;

1≤L≤R≤N1≤L≤R≤N;

−10000≤S1,S2,⋯,SN,V≤10000−10000≤S1,S2,⋯,SN,V≤10000.

Output

For every test case, you should output Case
#k:
 on a single line first, where kk indicates
the case number and starts at 11.
Then for every q query, output the answer on a single line. See sample
for more details.

Sample input and output

Sample Input Sample Output
1
5 6
0 1 2 3 4
q 1 4
a 1 2 -10
a 1 1 -6
a 5 5 -4
q 2 3
q 4 4
Case #1:
4
2
1

Source

The 9th UESTC Programming Contest Preliminary

【题解】

给你一个初始序列。

然后会不定期的问你这个序列在l..r的区间内最长(严格)上升子序列的长度。

但是还没完。这个序列是会发生改变的。

会定期把区间内的某一段同时递增或减少一个值。

要用线段树来解决。

但是线段树的域应该记录什么呢?

可以这样想。

一个区间内的最长上升子序列。要么整个全部在区间的左半部分。要么整个全部在区间的右半部分。

对不对??

傻逼

还有一种情况呢!

那就是横跨了中间这个域。一部分在左半部分一部分在右半部分。

是不是和hotel那题很像?

用llong[rt],rlong[rt]分别表示起点在(rt节点表示的区间的)左端点和终点在(rt节点表示的区间的)右端点的最长上升子序列的长度。

然后maxlong[rt]表示整个区间内不管在哪里的最长上升子序列的长度。

然后可以想象一下

如果rt的左儿子(x)和右儿子(y)他们满足

x的最右半那个元素<y的最左边那个元素。

那么就可以串成一个rlong[rt<<1]+llong[rt<<1|1]了。这就是横跨的情况了。

根据这个思路。我们还要在线段树的域上加上两个标志,分别记录这个节点表示的区间的最左边的那个元素和最右边的那个元素。

maxlong[rt] = max{maxlong[rt<<1],maxlong[rt<<|1]}

if (rnum[rt<<1]<lnum[rt<<1|1])

maxlong[rt] = max{maxlong,rlong[rt<<1]+llong[rt<<1|1]};

然后就是询问的一些繁琐的事情了。看代码吧。

【代码】

#include <cstdio>
#include <algorithm>
#define lson begin,m,rt<<1
#define rson m+1,end,rt<<1|1 using namespace std; const int MAXN = 100100; int n, m;
int maxlong[MAXN*4],llong[MAXN * 4],rlong[MAXN*4],rnum[MAXN*4],lnum[MAXN*4];
int lazy_tag[MAXN * 4]; void push_up(int rt,int len)//push_up会繁琐一些。
{
bool flag = rnum[rt << 1] < lnum[rt << 1 | 1];
maxlong[rt] = max(maxlong[rt<<1], maxlong[rt<<1|1]);
if (flag)
maxlong[rt] = max(maxlong[rt], rlong[rt << 1] + llong[rt << 1 | 1]);
llong[rt] = llong[rt << 1];//左儿子的最左边那段
if (llong[rt] == (len - (len >> 1)) && flag)//如果整个左儿子都递增 且flag(自己看是什么)
llong[rt] += llong[rt << 1 | 1];//那么就可以加上右儿子的左边部分。
rlong[rt] = rlong[rt << 1 | 1];
if (rlong[rt] == (len >> 1) && flag)
rlong[rt] += rlong[rt << 1];
lnum[rt] = lnum[rt << 1];
rnum[rt] = rnum[rt << 1 | 1];
} void build(int begin, int end, int rt) //建树顺便输入
{
maxlong[rt] = llong[rt] = rlong[rt] = lazy_tag[rt] = 0;
if (begin == end)
{
int x;
scanf("%d", &x);
llong[rt] = rlong[rt] = maxlong[rt] = 1;
rnum[rt] = lnum[rt] = x;
return;
}
int m = (begin + end) >> 1;
build(lson);
build(rson);
push_up(rt,end-begin+1);
} void input_data()
{
scanf("%d%d", &n, &m);
build(1, n, 1);
} void push_down(int rt)//处理懒惰标记
{
if (lazy_tag[rt] != 0)
{
lazy_tag[rt << 1] += lazy_tag[rt];
lazy_tag[rt << 1 | 1] += lazy_tag[rt];
lnum[rt << 1] += lazy_tag[rt];
rnum[rt << 1] += lazy_tag[rt];
lnum[rt << 1 | 1] += lazy_tag[rt];
rnum[rt << 1 | 1] += lazy_tag[rt];
lazy_tag[rt] = 0;
}
} void up_data(int l, int r, int num, int begin, int end, int rt)
{
if (l <= begin && end <= r)
{//递增的时候最长上升序列不会变。因为是一整段同时递增
lazy_tag[rt] += num;
lnum[rt] += num;
rnum[rt] += num;
return;
}
push_down(rt);
int m = (begin + end) >> 1;
if (l <= m)
up_data(l, r, num, lson);
if (m < r)
up_data(l, r, num, rson);
push_up(rt, end - begin + 1);
} int query(int l, int r, int begin, int end, int rt)//询问也有点复杂
{
if (l <= begin && end <= r)
return maxlong[rt];
push_down(rt);
int m = (begin + end) >> 1;
int temp = 0;
bool flag1 = false, flag2 = false;
if (l <= m)
{
temp = max(temp, query(l, r, lson));
flag1 = true;
}
if (m < r)
{
temp = max(temp, query(l, r, rson));
flag2 = true;
}
if (flag1 && flag2 && rnum[rt << 1] < lnum[rt << 1 | 1]) //如果有左半部分、右半部分。且能够串起来
{
int left = min(m - l + 1, rlong[rt << 1]);//不能超过询问的区间长度
int right = min(r - m, llong[rt << 1 | 1]);
temp = max(temp, left + right);//加起来
}
return temp;
} void output_ans()
{
for (int i = 1; i <= m; i++)
{
char op[5];
int x, y, z;
scanf("%s", op);
if (op[0] == 'a')
{
scanf("%d%d%d", &x, &y, &z);
up_data(x, y, z,1, n, 1);
}
else
if (op[0] == 'q')
{
scanf("%d%d", &x, &y);
printf("%d\n", query(x, y, 1, n, 1));
}
}
} int main()
{
//freopen("F:\\rush.txt", "r", stdin);
//freopen("F:\\rush_out.txt", "w", stdout);
int t;
scanf("%d", &t);
for (int ii = 1; ii <= t; ii++)
{
printf("Case #%d:\n",ii);
input_data();
output_ans();
}
return 0;
}

【37.07%】【UESTC 360】Another LCIS的更多相关文章

  1. 【黑金教程笔记之008】【建模篇】【Lab 07 数码管电路驱动】—笔记

    实验七的目的是设计实现最大为99数字在2个数码管上.采用同步动态扫描.即行信号和列信号同步扫描.这里数码管是共阳极的.选择端口也是共阳极的. 模块: /************************ ...

  2. 【Android开发VR实战】二.播放360&#176;全景视频

    转载请注明出处:http://blog.csdn.net/linglongxin24/article/details/53924006 本文出自[DylanAndroid的博客] [Android开发 ...

  3. 【西祠日志】【07】努力努力,找资料,思考,怎么做asp图片上传

    [西祠日志][07]努力努力,找资料.思考.怎么做asp图片上传  (2015.07.23周四) 今天忘了带本子.直接写在书上了笔记,晚点还是夹在本子里. 学了这么久的web应用,一直都没时间去做一点 ...

  4. 【面试】【Spring常见问题总结】【07】

    [常见面试问题总结文件夹>>>] 61.Spring IoC容器的依赖有两层含义: Bean依赖容器:也就是说Bean要依赖于容器,这里的依赖是指容器负责创建Bean并管理Bean的 ...

  5. 【2018.07.30】(广度优先搜索算法/队列)学习BFS算法小记

    一些BFS参考的博客: https://blog.csdn.net/ldx19980108/article/details/78641127 https://blog.csdn.net/u011437 ...

  6. 【docker-compose】使用docker-compose部署运行spring boot+mysql 【处理容器的时区问题】【详解】【福利:使用docker-compose构建 wordpress+mysql】

    ==================================================================================================== ...

  7. 【实战Java高并发程序设计 3】带有时间戳的对象引用:AtomicStampedReference

    [实战Java高并发程序设计 1]Java中的指针:Unsafe类 [实战Java高并发程序设计 2]无锁的对象引用:AtomicReference AtomicReference无法解决上述问题的根 ...

  8. 【更新】【封装必备】封装辅助 - 清理&优化工具 For Win7(IT天空会员专版)

    https://www.itsk.com/thread-353560-1-4.html nqawen 发表于 2015-7-9 17:26:37   本帖最后由 Amz 于 2015-11-25 10 ...

  9. 【剑指Offer学习】【全部面试题汇总】

    剑指Offer学习 剑指Offer这本书已经学习完了.从中也学习到了不少的东西,如今做一个总的文件夹.供自已和大家一起參考.学如逆水行舟.不进则退.仅仅有不断地学习才干跟上时候.跟得上技术的潮流! 全 ...

随机推荐

  1. 设计模式六大原则(五):迪米特法则(Law Of Demeter)

    定义: 一个对象应该对其他对象保持最少的了解. 问题由来: 类与类之间的关系越密切,耦合度越大,当一个类发生改变时,对另一个类的影响也越大. 解决方案: 尽量降低类与类之间的耦合. PS: 自从我们接 ...

  2. Font Awesome 图标如何使用

    Font Awesome 图标如何使用 一.总结 一句话总结:Font Awesome字体图标非常好用,直接引入font-awesome.css,然后就可以直接使用了,使用的时候是用的i标签. 1.字 ...

  3. Project Euler 389 Platonic Dice (概率)

    题目链接: https://projecteuler.net/problem=389 题意: 掷一个正四面体骰子,记点数为\(T\). 掷\(T\)个正六面体骰子,记点数和为\(C\). 掷\(C\) ...

  4. Event Serializers官网剖析(博主推荐)

    不多说,直接上干货! Flume Sources官网剖析(博主推荐) Flume Channels官网剖析(博主推荐) Flume Channel Selectors官网剖析(博主推荐) Flume ...

  5. Redis原理(二)

    运维 快照使用子进程是通过一个子进程完成, 它会比较的浪费资源的操作. 1.遍历整个内存,会增加系统负担. 2.io操作,降低redis性能. 一般都是主备,备用的进行持久化. Redis 4.0混合 ...

  6. ORA-01665 control file is not a standby control file

    ORA-01665错误处理 问题描述: 在备库启动至mount状态时,报如下错误: ORA-01665: control file is not a standby control file 解决办法 ...

  7. [D3] Build an Area Chart with D3 v4

    Similar to line charts, area charts are great for displaying temporal data. Whether you’re displayin ...

  8. amazeui学习笔记--css(常用组件7)--输入框组Input-group

    amazeui学习笔记--css(常用组件7)--输入框组Input-group 一.总结 1.使用:Input group 基于 Form 组件和 Button 组件扩展,依赖这两个组件.在容器上添 ...

  9. C++组合数(combination)的实现

    实现: (nm) 既需要计算组合的总数 (32)=3: 也需要分别获得每一种组合的情形,用于穷举搜索: 1, 2; 1, 3; 2, 3 1. 递归实现 // picked + toPick == m ...

  10. Altium Designer如何创建类,如何修改线宽

    如果线宽还是没有改变,就是因为,有一个默认的class,它的规则优先级要高于PWR