HDU - 1754 I Hate It【线段树】

I Hate It

Time Limit: 9000/3000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 108841 Accepted Submission(s): 40748

Problem Description
很多学校流行一种比较的习惯。老师们很喜欢询问，从某某到某某当中，分数最高的是多少。
这让很多学生很反感。

不管你喜不喜欢，现在需要你做的是，就是按照老师的要求，写一个程序，模拟老师的询问。当然，老师有时候需要更新某位同学的成绩。

Input
本题目包含多组测试，请处理到文件结束。
在每个测试的第一行，有两个正整数 N 和 M ( 0 学生ID编号分别从1编到N。
第二行包含N个整数，代表这N个学生的初始成绩，其中第i个数代表ID为i的学生的成绩。
接下来有M行。每一行有一个字符 C (只取’Q’或’U’) ，和两个正整数A，B。
当C为’Q’的时候，表示这是一条询问操作，它询问ID从A到B(包括A,B)的学生当中，成绩最高的是多少。
当C为’U’的时候，表示这是一条更新操作，要求把ID为A的学生的成绩更改为B。

Output
对于每一次询问操作，在一行里面输出最高成绩。

Sample Input
5 6
1 2 3 4 5
Q 1 5
U 3 6
Q 3 4
Q 4 5
U 2 9
Q 1 5

Sample Output
5
6
5
9

HintHuge input,the C function scanf() will work better than cin

Author
linle

链接：http://acm.hdu.edu.cn/showproblem.php?pid=1754

简述：输出一组数据表示（第i个数字是第i个同学的分数），输入Q，a , b表示查询a , b区间最大值，输入U， a, b表示将第a个同学的分数改成b；

分析：即线段树的区间查询跟单点修改。分别写三个函数。
①build：1.区间为叶子节点 2.（否则）（不用写条件）递归建树（两个都有赋值）
②check: 1.a,b包含了k节点表示的区间 2.a,b与当前区间没有交集 3.（否则）（不用写条件）有部分交集，递归查询
③update: 1.所更新点为叶子节点 2.所更新点不在区间内（这里仍然要返回节点最大值） 3.（否则）（不用写条件）：递归更新

说明：这一题坑真的不是一般的多。。。而且还有些地方不大懂
①结构体数组开四倍大
②使用scanf输入输出流
（由于对C不是很熟悉，栽的跟头太多，
比如以为!=EOF可以省略不写，
比如把输出写成输入，
比如不知道单字符输入是%c，
比如输入数组元素的时候忘记加&符号）
③输入字符前用getchar()过滤
④甚至会把||写成&&导致超时，多加了小于号WA
⑤把build的顺序放在了输入数组前面（要放后面），build赋值方向写反了

参考题解链接：https://blog.csdn.net/panyanyany/article/details/6776300

AC代码如下：

#include 
#include 
#include 
#include 
#include 
using namespace std;
int max(int a, int b)
{
	if (a > b)
		return a;
	else 
		return b;
}
int n, m, sco[200010];
struct Node
{
	int l, r, max;
};
Node node[4 * 200010];
int build(int k, int l, int r)
{
	//赋值方向是已知的参数赋给未知的节点
	node[k].r = r;
	node[k].l = l;
	if (node[k].r == node[k].l)
		return node[k].max = sco[l];	//有赋值
	int mid;
	mid = (l + r) / 2;
	int a, b;
	a = build(2 * k, l, mid);
	b = build(2 * k + 1, mid + 1, r);
	return node[k].max = max(a, b);	//有赋值
}
int check(int k, int a, int b)
{
	//如果a，b点包含了区间
	if (a <= node[k].l && b >= node[k].r)
		return node[k].max;
	//如果a，b在区间外面
	//多写了等于号
	if (b < node[k].l || a > node[k].r)
		return 0;
	//如果a，b与区间部分相交
	//不用写限制条件
	int c, d;
	//这一块有点懵
	//int mid;
	//mid = (node[k].l + node[k].r) / 2;
	//总觉得这里的参数应该要变成mid
	c = check(2 * k, a, b);
	d = check(2 * k + 1, a, b);
	return max(c, d);
}
int update(int k, int a, int b)
{
	//如果该点跟区间点相同
	if (a == node[k].l && a == node[k].r)
		return node[k].max = b;
	//如果该点不在区间内
	if (a < node[k].l || a > node[k].r)
		return node[k].max;	
	//表示不懂为什么不返回0，而且为什么非要加这条
	//下面不用写条件
	int c, d;
	c = update(2 * k, a, b);
	d = update(2 * k + 1, a, b);
	 return node[k].max = max(c, d);
}
int main()
{
	int i, a, b;
	char c;
	while (scanf("%d%d", &n, &m) != EOF)
	{
		for (i = 1; i <= n; i++)
			scanf("%d", &sco[i]);
		//顺序不能调转
		build(1, 1, n);
		while (m--) {
			getchar();
			scanf("%c%d%d", &c, &a, &b);
			if(c == 'Q') printf("%d\n",check(1, a, b));
			if (c == 'U') update(1, a, b);
		}
	}
}

#include 
#include 
#include 
#include 
#include 
using namespace std;
int max(int a, int b)
{
	if (a > b)
		return a;
	else 
		return b;
}
int n, m, sco[200010];
struct Node
{
	int l, r, max;
};
Node node[4 * 200010];
int build(int k, int l, int r)
{
	//赋值方向是已知的参数赋给未知的节点
	node[k].r = r;
	node[k].l = l;
	if (node[k].r == node[k].l)
		return node[k].max = sco[l];	//有赋值
	int mid;
	mid = (l + r) / 2;
	int a, b;
	a = build(2 * k, l, mid);
	b = build(2 * k + 1, mid + 1, r);
	return node[k].max = max(a, b);	//有赋值
}
int check(int k, int a, int b)
{
	//如果a，b点包含了区间
	if (a <= node[k].l && b >= node[k].r)
		return node[k].max;
	//如果a，b在区间外面
	//多写了等于号
	if (b < node[k].l || a > node[k].r)
		return 0;
	//如果a，b与区间部分相交
	//不用写限制条件
	int c, d;
	//这一块有点懵
	//int mid;
	//mid = (node[k].l + node[k].r) / 2;
	//总觉得这里的参数应该要变成mid
	c = check(2 * k, a, b);
	d = check(2 * k + 1, a, b);
	return max(c, d);
}
int update(int k, int a, int b)
{
	//如果该点跟区间点相同
	if (a == node[k].l && a == node[k].r)
		return node[k].max = b;
	//如果该点不在区间内
	if (a < node[k].l || a > node[k].r)
		return node[k].max;	
	//表示不懂为什么不返回0，而且为什么非要加这条
	//下面不用写条件
	int c, d;
	c = update(2 * k, a, b);
	d = update(2 * k + 1, a, b);
	 return node[k].max = max(c, d);
}
int main()
{
	int i, a, b;
	char c;
	while (scanf("%d%d", &n, &m) != EOF)
	{
		for (i = 1; i <= n; i++)
			scanf("%d", &sco[i]);
		//顺序不能调转
		build(1, 1, n);
		while (m--) {
			getchar();
			scanf("%c%d%d", &c, &a, &b);
			if(c == 'Q') printf("%d\n",check(1, a, b));
			if (c == 'U') update(1, a, b);
		}
	}
}