Codeforces 438D The Child and Sequence（线段树）

题目链接The Child and Sequence

题意：每次对一个数组进行三种操作

1.求出区间[L,R]和并输出

2.将区间[L,R]每个元素都对X取余

3.将位置K上的数修改成X

题解：一眼看出这必定和线段树有关系，但是取余又好像不能处理，我们发现操作3中是单点修改而不是区间修改，这很反常，思考是否可以暴力，我们可以发现a mod m<，那么就意味着一个点最多被有效取余logn次，而且操作3是单点修改，我们可以线段树维护区间最大值和区间和，每次判断下如果区间最大值小于取余的数，那么就不需要取余，其他点直接暴力取余，复杂度最差为O(nlogn^2)

代码很简单，就是普通线段树，难在思维

#include<iostream>
#include<stack>
#include<list>
#include<set>
#include<vector>
#include<algorithm>
#include<math.h>
#include<numeric>
#include<map>
#include<cstring>
#include<queue>
#include<iomanip>
#include<cmath>
#include<queue>
#include <bitset>
#include<unordered_map>
	#ifndef local
	#define endl '\n'
#endif */
#define mkp make_pair
using namespace std;
using std::bitset;
typedef long long ll;
typedef long double ld;
const int inf=0x3f3f3f3f;
const ll MAXN=2e6+10;
const ll N=1e5+100;
const ll mod=1e9+7;
const ll hash_p1=1610612741;
const ll hash_p2=805306457;
const ll hash_p3=402653189;
//-----------------------------------------------------------------------------------------------------------------*/
// ll head[MAXN],net[MAXN],to[MAXN],edge[MAXN]/*流量*/,cost[MAXN]//费用;
/* 
void add(ll u,ll v,ll w,ll s){
	to[++cnt]=v;net[cnt]=head[u];edge[cnt]=w;cost[cnt]=s;head[u]=cnt;
	to[++cnt]=u;net[cnt]=head[v];edge[cnt]=0;cost[cnt]=-s;head[v]=cnt;
}
struct elemt{
	int p,v;
};
struct comp{
	public:
		bool operator()(elemt v1,elemt v2){
			return v1.v<v2.v;
		}
};
-----------------------------------
求[1,MAXN]组合式和逆元 
ll mi(ll a,ll b){
	ll res=1;
	while(b){
		if(b%2){
			res=res*a%mod;
		}	
		a=a*a%mod;
	}
	return res;
}
ll fac[MAXN],inv[MAXN]
fac[0]=1;inv[0]=1;
for(int i=1;i<=MAXN;i){
	fac[i]=(fac[i-1]*i)%mod;
	inv[i]=mi(fac[i],mod-2);
}
ll C(int m,int n){//组合式C(m,n); 
	if(!n){
		return 1;
	}
	return fac[m]*(inv[n]*inv[m*-n]%mod)%mod;
}
---------------------------------
 unordered_map<int,int>mp;
//优先队列默认小顶堆 ， greater<int> --小顶堆  less<int> --大顶堆  
priority_queue<elemt,vector<elemt>,comp>q;
	set<int>::iterator it=st.begin();
*/
// vector<vector<int>>edge; 二维虚拟储存坐标 
//-----------------------------------------------------------------------------------------------------------------*/
  //map<int,bool>mp[N]; 
int maxn[4*N];//维护区间最大值
ll sum[4*N];//区间和
int a[N];
void pushup(int rt){
	sum[rt]=sum[2*rt]+sum[2*rt+1];
	maxn[rt]=max(maxn[2*rt],maxn[2*rt+1]);
}
void build(int l,int r,int rt){
	if(l==r){
		sum[rt]=a[l];
		maxn[rt]=a[l];
		return ;
	}
	int mid=(l+r)/2;
	build(l,mid,2*rt);
	build(mid+1,r,2*rt+1);
	pushup(rt);
}
ll query(int l,int r,int rt,int le,int ri){
	if(le<=l&&ri>=r){
		return sum[rt];
	}
	int mid=(l+r)/2;
	ll res=0;
	if(le<=mid){
		res+=query(l,mid,2*rt,le,ri);
	}
	if(ri>mid){
		res+=query(mid+1,r,2*rt+1,le,ri);
	}
	return res;
}
void update(int l,int r,int rt,int k,int x){
	if(l==r){
		sum[rt]=x;
		maxn[rt]=x;
		return ;
	}
	int mid=(l+r)/2;
	if(k<=mid){
		update(l,mid,2*rt,k,x);
	}
	if(k>mid){
		update(mid+1,r,2*rt+1,k,x);
	}
	pushup(rt);
}
void modify(int l,int r,int rt,int le,int ri,int m){//暴力更新每个节点
	if(maxn[rt]<m){
		return ;
	}
	if(l==r){//
		sum[rt]%=m;
		maxn[rt]%=m;
		return;
	}
	int mid=(l+r)/2;
	if(le<=mid){
		modify(l,mid,2*rt,le,ri,m);
	}
	if(ri>mid){
		modify(mid+1,r,2*rt+1,le,ri,m);
	}
	pushup(rt);
}
int main(){
/*cout<<setiosflags(ios::fixed)<<setprecision(8)<<ans<<endl;//输出ans（float）格式控制为8位小数（不含整数部分）*/
/*cout<<setprecision(8)<<ans<<endl;//输出ans（float）格式控制为8位小数（含整数部分）*/
	ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);//同步流
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	build(1,n,1);
	while(m--){
		int k,l,r,x;
		cin>>k;
		if(k==1){
			cin>>l>>r;
			cout<<query(1,n,1,l,r)<<endl;
		}
		else if(k==2){
			cin>>l>>r>>x;
			modify(1,n,1,l,r,x);
		}
		else{
			cin>>k>>x;
			update(1,n,1,k,x);
		}
	}
	return 0;
}