#1077 : RMQ问题再临-线段树

时间限制: 10000ms

单点时限: 1000ms

内存限制: 256MB

描述

上回说到：小Hi给小Ho出了这样一道问题：假设整个货架上从左到右摆放了N种商品，并且依次标号为1到N，每次小Hi都给出一段区间[L, R]，小Ho要做的是选出标号在这个区间内的所有商品重量最轻的一种，并且告诉小Hi这个商品的重量。但是在这个过程中，可能会因为其他人的各种行为，对某些位置上的商品的重量产生改变（如更换了其他种类的商品）。

小Ho提出了两种非常简单的方法，但是都不能完美的解决。那么这一次，面对更大的数据规模，小Ho将如何是好呢？

提示：其实只是比ST少计算了一些区间而已

输入

每个测试点（输入文件）有且仅有一组测试数据。

每组测试数据的第1行为一个整数N，意义如前文所述。

每组测试数据的第2行为N个整数，分别描述每种商品的重量，其中第i个整数表示标号为i的商品的重量weight_i。

每组测试数据的第3行为一个整数Q，表示小Hi总共询问的次数与商品的重量被更改的次数之和。

每组测试数据的第N+4~N+Q+3行，每行分别描述一次操作，每行的开头均为一个属于0或1的数字，分别表示该行描述一个询问和描述一次商品的重量的更改两种情况。对于第N+i+3行，如果该行描述一个询问，则接下来为两个整数Li, Ri，表示小Hi询问的一个区间[Li, Ri]；如果该行描述一次商品的重量的更改，则接下来为两个整数Pi，Wi，表示位置编号为Pi的商品的重量变更为Wi

对于100%的数据，满足N<=10^6，Q<=10^6, 1<=Li<=Ri<=N，1<=Pi<=N, 0<weight_i, Wi<=10^4。

输出

对于每组测试数据，对于每个小Hi的询问，按照在输入中出现的顺序，各输出一行，表示查询的结果：标号在区间[Li, Ri]中的所有商品中重量最轻的商品的重量。

样例输入

10
3655 5246 8991 5933 7474 7603 6098 6654 2414 884 
6
0 4 9
0 2 10
1 4 7009
0 5 6
1 3 7949
1 3 1227

样例输出

2414
884
7474

题解：其实就是递归将数组区间平均分成两份，也就是左孩子和右孩子，每个节点都保存了孩子节点的最值，所以能求出区间最值。但是不能进行删除元素和插入元素，只能解决区间查询。由于是完全二叉树，所以左孩子下标肯定是父节点的2倍，右孩子就是左孩子下标+1.。

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

const int maxn = 1000005;
 
int a[maxn];       //保存信息 

struct Array
{
	int left;     //左区间 
	int right;    //右区间 
	int num;      //商品重量 
};

Array sa[2 * maxn];   //保存线段树信息 

void segBuild(int st,int l,int r) //建立线段树 
{
	sa[st].left = l;              //该节点保存的是哪个区间 
	sa[st].right = r;
	if(l == r)                   //左右区间相等，说明该点是叶子节点，叶子节点保存商品重量 
	{
		sa[st].num = a[l];
		return;
	}
	segBuild(2 * st,l,(l + r) / 2);        //先去左孩子去找 
	segBuild(2 * st + 1,(l + r) / 2 + 1,r);//再去右孩子找 
	sa[st].num = min(sa[2 * st].num,sa[2 * st + 1].num);  //该父节点保存左右孩子重量小的一个	
}

void update(int st,int pi,int wi)    //从祖先开始找修改节点的信息 
{
	if(sa[st].left == sa[st].right)  //找到该节点(就是left = right = pi)，修改信息 
	{
		sa[st].num = wi;
		return;
	}
	
	int mid = (sa[st].left + sa[st].right) / 2;
	if(pi <= mid)                   //该节点属于父亲左孩子 
	{
		update(2 * st,pi,wi);
	}
	else                           //该节点属于父亲右孩子 
	{
		update(2 * st + 1,pi,wi); 
	}
	sa[st].num = min(sa[2 * st].num,sa[2 * st + 1].num); 	//更新父亲保存重量的最小值，去孩子中较小的一个 
}

int query(int st,int l,int r)     //1. l,r与某个节点区间刚好一致。 
{                                 //2. l,r属于节点左孩子 
	int minnum = 1000000;         //3. l,r属于节点右孩子 
	if(sa[st].left == l && sa[st].right == r)  //4. l,r横跨左右孩子,则该节点取其中小的一个 
	{
		return sa[st].num;
	}
	
	int mid = (sa[st].left + sa[st].right) / 2;
	if(r <= mid)                   //属于左区间 
	{
		return query(2 * st,l,r);
	}
	if(l > mid)                   //属于右区间 
	{
		return query(2 * st + 1,l,r);
	}
	return min(query(2 * st,l,mid),query(2 * st + 1,mid + 1,r));//横跨左右孩子 
}

int main()
{
	int n;
	cin>>n;
	memset(sa,100000,sizeof(sa));
	for(int i = 1;i <= n;i++)
	{
		scanf("%d",a + i);
	}
	
	segBuild(1,1,n);  //祖先下标为为1
	
	int q;
	cin>>q;
	int flag,pi,wi;
	for(int i = 0;i < q;i++)
	{
		scanf("%d%d%d",&flag,&pi,&wi);
		if(0 == flag)
		{
			printf("%d\n",query(1,pi,wi));
		}
		else
		{
			update(1,pi,wi);
		}
	}
}