蓝桥杯 算法提高 Sequence （线段树）

题目：

对于一个包含n个元素的序列A[0],A[1],A[2],A[3]……A[n - 1]可以进行一下三种操作
　　A l r d:使A[l],A[l+1],A[l+2]……A[r]均+d(保证a≤b)
　　M l r d:使A[l],A[l+1],A[l+2]……A[r]均×d(保证a≤b)
　　Q l r:查询A[l]+A[l+1]+A[l+2]+……+A[r]的和
　　序列中每一个数的初始值为0
　　输入格式
　　第一行输入两个整数n,m表示序列的长度为n,有m次操作。
　　之后输入m行，每行一个操作。
输出格式
　　对于每次查询输出一行一个整数表示查询的结果，由于结果可能过大，输出其对10007取模的结果即可。
样例输入
5 6
A 2 4 2
M 0 4 5
Q 1 3
M 1 2 3
Q 0 3
Q 1 4
样例输出
10
40
50
数据规模和约定
　　n ≤ 100000.
　　m ≤ 20000.
　　d ≤ 1000

思路：线段树

很明显这是一个模板题，简单的线段树区间加法和区间乘法的混合。线段树是一个比较复杂的一个数据结构，但是效率也是很耐斯的。
如果对模板不熟悉的话可以看一下我的另一篇文章：
线段树基础（超详细）
这道题犯得错竟然是数组没开够，数组应该开4N规模的，但是我只给看2N的。
具体还是看图吧。

AC代码：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;


public class Main
{
	static int mod=10007;
	static long segment_tree[];
	static long lazy[];
	static long mul[];
	private static int N;
	public static void main(String[] args) {
		Scanner in =new Scanner(System.in);
		N = in.nextInt();int M=in.nextInt();
		segment_tree=new long[4*N-1];
		lazy=new long[4*N-1];
		mul=new long[4*N-1];
		ArrayList<Long> tt=new ArrayList<Long>();
		Arrays.fill(segment_tree, 0);
		Arrays.fill(mul, 1);
		String t;
		for(int i=0;i<M;i++)
		{
			t=in.next();
			if(t.equals("A"))
				update_range(in.nextInt(),in.nextInt(),0,N-1,1,in.nextInt(),false);
			else if(t.equals("M"))
				update_range(in.nextInt(),in.nextInt(),0,N-1,1,in.nextInt(),true);
			else 
				tt.add(query(in.nextInt(), in.nextInt(),0,N-1, 1));
		}
		for(int i=0;i<tt.size();i++)
			System.out.println(tt.get(i));
		
}
	static void push_down(int node,int L,int R)  //下传lazy标记
	{
		if(lazy[node]!=0||mul[node]!=1)   //如果有标记则执行
		{
			int mid=(L+R)>>1;
			segment_tree[node<<1]=(segment_tree[node<<1]*mul[node]%mod+lazy[node]*(mid-L+1))%mod;
			segment_tree[node<<1|1]=(segment_tree[node<<1|1]*mul[node]%mod+lazy[node]*(R-mid))%mod;
			
			mul[node<<1]=mul[node]*mul[node<<1]%mod;
			mul[node<<1|1]=mul[node]*mul[node<<1|1]%mod;
			
			
			lazy[node<<1]=(lazy[node<<1]*mul[node]%mod+lazy[node])%mod; 
			lazy[node<<1|1]=(lazy[node<<1|1]*mul[node]%mod+lazy[node]%mod);
			
			lazy[node]=0;
			mul[node]=1;
		}
	}
	//added 为被加值 l和r为被加的区间端点   L表示为当前区间的左端点 R表示为当前区间的右端点 node为当前节点的下标
	static void update_range(int l,int r,int L,int R,int node,int num,boolean flag)
	{
		if(l<=L&&r>=R)  //如果要更新的区间全部覆盖了当前区间
		{
			if(flag)  //如果是乘法
			{
				lazy[node]=lazy[node]*num%mod;
				mul[node]=mul[node]*num%mod;
				segment_tree[node]=segment_tree[node]*num%mod;
			}
			else 
			{
				lazy[node]=(lazy[node]+num)%mod;    //添加lazy标记，先不下传lazy标记
				segment_tree[node]=(segment_tree[node]+(R-L+1)*num%mod)%mod;
			}
			return;
		}
		push_down(node,L,R);
		int mid=(L+R)>>1;
		if(mid>=l) update_range(l, r, L, mid, node<<1,num,flag);
		if(mid<r) update_range( l, r, mid+1, R, node<<1|1,num,flag); //mid<r的原因是mid是左孩子的右端，mid+1是右孩子的左端
		segment_tree[node]=(segment_tree[node<<1]+segment_tree[node<<1|1])%mod;
	}
	
	static long query(int l,int r,int L,int R,int node)
	{
		if(l<=L&&r>=R) 
			return segment_tree[node]; //当所查找的区间覆盖当前区间时 
			
		push_down(node,L,R);
		int mid=(L+R)/2;
		long sum=0;
		if(mid>=l) sum=(sum+query(l,r,L,mid,node<<1))%mod;
		if(mid<r) sum=(sum+query(l,r,mid+1,R,node<<1|1))%mod;
		return sum;
	}
}