动态最大连续子段和 [线段树]

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();
	}
}