Learning
一般涉及操作：单点修改，区间查询最大连续子段和
线段树维护最大子段和的具体思路：
①线段树需要维护的是：
_1.[x,y]内的最大子段和 ms
_2.[x,y]的区间和 s
_3.[x,y]内的紧靠左端点的最大子段和 ls
_4.[x,y]内的紧靠右端点的最大子段和 rs
②维护方法：
ls有两种情况：
_1.左儿子的ls
_2.左儿子的s+右儿子的 ls
同理，rs有两种情况：
_1.右儿子的rs
_2.右儿子的s+左儿子的 rs
s有三种情况：
_1.左儿子的s
_2.右儿子的s
_3.左儿子的rs+右儿子的 ls
③询问方法：
[L,R]区间的最大连续子段和有以下几种情况：
_1.独立的存在于左儿子或右儿子中
_2.左儿子的rs+右儿子的ls
然而如果[L,R] 在线段树中是一个节点（我们单独维护过），那么直接return t[k]这个节点就可以了
Practice
[洛谷 4513] 小白逛公园
题意：n个数，m个操作，操作一单点修改，操作二区间查询最大连续子段和。(n<=500000, m<=100000)
思路：模板。
#include<iostream>
#include<stdio.h>
#include<string.h>
#include<map>
#include<algorithm>
#include<queue>
#include<math.h>
#include<set>
#include<vector>
using namespace std;
#define Inf 0x7fffffff
typedef long long ll;
const int N=5e5+7;
struct node{
ll ms,ls,rs,s;
}t[N*4];
int n,m;
ll a[N];
void push_up(int k){
int lson=k<<1,rson=k<<1|1;
t[k].s=t[lson].s+t[rson].s;
t[k].ls=max(t[lson].ls,t[lson].s+t[rson].ls);
t[k].rs=max(t[rson].rs,t[rson].s+t[lson].rs);
t[k].ms=max(max(t[lson].ms,t[rson].ms),t[lson].rs+t[rson].ls);
}
void build(int l,int r,int k){
if(l==r){
t[k].ls=t[k].rs=t[k].ms=t[k].s=a[l];
return;
}
int mid=(l+r)>>1;
build(l,mid,k<<1);
build(mid+1,r,k<<1|1);
push_up(k);
}
void modify(int pos,int l,int r,int k,int val){
if(l==r){
t[k].ls=t[k].rs=t[k].ms=t[k].s=val;
return;
}
int mid=(l+r)>>1;
if(pos<=mid)modify(pos,l,mid,k<<1,val);
else modify(pos,mid+1,r,k<<1|1,val);
push_up(k);
}
node query(int L,int R,int l,int r,int k){
if(L<=l&&R>=r)return t[k];//完全包含
int mid=(l+r)>>1;
node al,ar,ans;
ans.s=0;
if(R<=mid)ans=query(L,R,l,mid,k<<1);//全部在左儿子
if(L>mid)ans=query(L,R,mid+1,r,k<<1|1);//全部在右儿子
if(L<=mid&&R>mid){//询问区间被分成两部分
al=query(L,R,l,mid,k<<1);
ar=query(L,R,mid+1,r,k<<1|1);
ans.s=al.s+ar.s;
ans.ls=max(al.ls,al.s+ar.ls);
ans.rs=max(ar.rs,ar.s+al.rs);
ans.ms=max(max(al.ms,ar.ms),al.rs+ar.ls);
}
return ans;
}
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++)scanf("%lld",&a[i]);
build(1,n,1);
for(int i=1;i<=m;i++){
int opt,x,y;
scanf("%d%d%d",&opt,&x,&y);
if(opt==1){
if(x>y)x^=y^=x^=y;
node ans=query(x,y,1,n,1);
printf("%lld\n",ans.ms);
}else modify(x,1,n,1,y);
}
}
[hdu 6638] Snowy Smile
题意：题意：给n<=2000个点，每个点一个坐标(Xi,Yi)，-1e9<=Xi,Yi<=1e9，和一个值wi(有负数)，找一个矩形，使其框起来的点的wi值和最大。(稀疏点的最大子矩阵和)
思路：思路：离散化+枚举上下边界降维、加点+线段树维护一维的最大连续子段和
#include<bits/stdc++.h>
using namespace std;
#define Inf 0x7fffffff
typedef long long ll;
const int N=2010;
int T,n,X[N],Y[N];
struct point{
int x,y;
ll w;
}p[N];
struct node{
ll ms,ls,rs,s;
}t[N*4];
void push_up(int k){
int lson=k<<1,rson=k<<1|1;
t[k].s=t[lson].s+t[rson].s;
t[k].ls=max(t[lson].ls,t[lson].s+t[rson].ls);
t[k].rs=max(t[rson].rs,t[rson].s+t[lson].rs);
t[k].ms=max(max(t[lson].ms,t[rson].ms),t[lson].rs+t[rson].ls);
}
void add(int pos,int l,int r,int k,ll val){
if(l==r){
t[k].s=t[k].ls=t[k].rs=t[k].ms+=val;
return;
}
int mid=(l+r)>>1;
if(pos<=mid)add(pos,l,mid,k<<1,val);
else add(pos,mid+1,r,k<<1|1,val);
push_up(k);
}
vector<point>ve[N];
int main(){
cin>>T;
while(T--){
scanf("%d",&n);
for(int i=1;i<=n;i++){//离散化
scanf("%d%d%lld",&p[i].x,&p[i].y,&p[i].w);
X[i]=p[i].x;
Y[i]=p[i].y;
}
sort(X+1,X+1+n);
sort(Y+1,Y+1+n);
int size1=unique(X+1,X+1+n)-X-1;
int size2=unique(Y+1,Y+1+n)-Y-1;
for(int i=1;i<=n;i++){
p[i].x=lower_bound(X+1,X+1+size1,p[i].x)-X;
p[i].y=lower_bound(Y+1,Y+1+size2,p[i].y)-Y;
ve[p[i].y].push_back(p[i]);
}
ll ans=0;
for(int i=1;i<=size2;i++){//枚举上边界
for(int j=1;j<=size1*4;j++) //清空线段树
t[j].s=t[j].ls=t[j].rs=t[j].ms=0;
for(int j=i;j;j--){//枚举下边界
for(auto k:ve[j])add(k.x,1,size1,1,k.w);
ans=max(ans,t[1].ms);
}
}
cout<<ans<<"\n";
for(int i=1;i<=size2;i++)ve[i].clear();
}
}