线段树（单点修改，区间查询）

引入

$题目描述$

$10000$个正整数，编号从$1$到$10000$，用$A[1]$,$A[2]$,$A[10000]$表示。 修改：1.将第 $pos$ 个数增加 $val$ $（1 <= L <= 10000）$ 统计：1.编号从 $L$ 到 $R$ 的所有数之和为多少？ 其中 $1<= L <= R <= 10000.$

方法如下（目前所学）：

1. 修改 $A[pos]$ ——$O(1)$ ；循环求和 ——$O(n)$
2. 差分：修改 $n$ 个元素 $O(n)$ ; 令 S[0]=0, S[k]=A[1..k] ，那么，A[L..R]的和就等于S[R]-S[L-1] ———$O(1)$

从上可以看出 方法一修改快，求和慢。 方法二求和快，修改慢。 那有没有一种结构，修改和求和都比较快呢？答案当然是$线段树$

线段树的单点修改

1、分解区间

首先是讲原始子区间的分解，假定给定区间$[L,R]$，只要$L < R$ ，线段树就会把它继续分裂成两个区间。

首先计算 $M = (L+R)/2$，左子区间为$[L,M]$，右子区间为$[M+1,R]$，然后如果子区间不满足条件就递归分解。

2、

---

模板

#include<bits/stdc++.h>
using namespace std;

int read()
{
    int s=0; char c=getchar();
    for (;!isdigit(c);c=getchar());
    for (;isdigit(c);c=getchar()) s=s*10+c-'0';
    return s;
}

const int maxn=1e5;
int n,m;
struct Tree
{
	int left,right,val=INT_MAX;	
}tree[maxn*4+99];

void build(int k,int l,int r)
{
	tree[k].left=l;
	tree[k].right=r;
	
	if(l==r)
	{
		tree[k].val=read();
		return;
	}
	
	int mid=(l+r)/2;
	int left=k*2,right=k*2+1;
	
	build(left,l,mid);
	build(right,mid+1,r);
	
	tree[k].val=min(tree[left].val,tree[right].val);
}

void update(int o,int pos,int val)
{
	
	if(tree[o].left==tree[o].right)
	{
		tree[o].val=val;
		return;
	}
	
	int mid=(tree[o].left+tree[o].right)/2;
	int left=o*2,right=o*2+1;
	
	if(pos<=mid)
	{
		update(left,pos,val);
	}
	else
	{
		update(right,pos,val);
	}
	
	tree[o].val=min(tree[left].val,tree[right].val);
}

int query(int o,int L,int R)
{
	
	if(L<=tree[o].left&&R>=tree[o].right)
	{
		return tree[o].val;
	}
	
	int mid=(tree[o].left+tree[o].right)/2;
	int left=o*2,right=o*2+1;
	int sum1=INT_MAX,sum2=INT_MAX;
	
	if(L<=mid)
	{
		sum1=query(left,L,R);
	}
	if(R>mid)
	{
		sum2=query(right,L,R);
	}
	
	return min(sum1,sum2);
}

signed main()
{
	cin>>n>>m;
	build(1,1,n);
	//for(int i=1;i<=n;i++)cout<<summ[i]<<" ";
	//cout<<endl;
	for(int i=1;i<=m;i++)
	{
		int q,l,r;
		q=read();
		l=read();
		r=read();
		if(q==2)
		{
			update(1,l,r);
		}
		else
		{
			cout<<query(1,l,r)<<" ";
		}
	}
}