线段树2板子 区间加与乘

 当对区间即有加操作，又有乘操作时：

//乘法满足分配率！！，所以乘懒标记可以“攻击”加懒标记
//策略：两个标记都安排
//当乘标记来临时，对自己和懒标记都乘//假设都没有向后延伸
//
//（特别好的分析：）
//当加标记来临时，正常加就好啦，因为乘已经对加处理啦
//
//两个一起来临呢，先乘！！！！！！！！！！！！！！！！！
//(乘已经对这部分加处理过了)

 （这里update2是乘法）

int MOD = 19930726;
#define int long long
#define ll long long
class ST//segment tree
{
	struct node
	{
		ll val;
		int t1;
		int t2;//乘
		node(int v = 0) :val(v), t1(0), t2(1)//x2x3 == x6
		{}
	};
	int n = a.size();
	vector<ll>a;
	vector<node>d;
	void build_tree(int i, int l, int r)
	{
		if (l == r)
		{
			d[i].val = a[l] % MOD;
			return;
		}
		int mid = l + (r - l) / 2;
		build_tree(i * 2, l, mid);
		build_tree(i * 2 + 1, mid + 1, r);
		d[i].val = d[i * 2].val + d[i * 2 + 1].val;
	}
	void spread(int i, int l, int r, int aiml, int aimr)
	{
		//懒惰
		int mid = l + (r - l) / 2;
		//if ((d[i].t1 != 0 || d[i].t2 != 1) && l != r)
		//{
		int t1 = d[i].t1, t2 = d[i].t2;
		//先乘
		d[i * 2].val = (d[i * 2].val * t2) % MOD;
		d[i * 2].t1 = (d[i * 2].t1 * t2) % MOD;
		d[i * 2].t2 = (d[i * 2].t2 * t2) % MOD;
		d[i * 2 + 1].val = (d[i * 2 + 1].val * t2) % MOD;
		d[i * 2 + 1].t1 = (d[i * 2 + 1].t1 * t2) % MOD;
		d[i * 2 + 1].t2 = (d[i * 2 + 1].t2 * t2) % MOD;

		//后加
		d[i * 2].val = (d[i * 2].val + t1 * (mid - l + 1)) % MOD;
		d[i * 2 + 1].val = (d[i * 2 + 1].val + t1 * (r - mid)) % MOD;
		d[i * 2].t1 = (d[i * 2].t1 + t1) % MOD;
		d[i * 2 + 1].t1 = (d[i * 2 + 1].t1 + t1) % MOD;

		//复原
		d[i].t1 = 0;
		d[i].t2 = 1;
		//}
		/// 
	}
	ll _getsum(int i, int l, int r, int aiml, int aimr)
	{
		if (aiml <= l && r <= aimr)
			return d[i].val;

		int mid = l + (r - l) / 2;
		spread(i, l, r, aiml, aimr);

		ll ret = 0;
		if (aiml <= mid)
			ret = (ret + _getsum(i * 2, l, mid, aiml, aimr)) % MOD;

		if (aimr >= mid + 1)
			ret = (ret + _getsum(i * 2 + 1, mid + 1, r, aiml, aimr)) % MOD;
		return ret;

	}
	void _update1(int i, int l, int r, int aiml, int aimr, ll val)
	{
		if (aiml <= l && r <= aimr)
		{
			d[i].t1 = (d[i].t1 + val) % MOD;
			d[i].val = (d[i].val + val * (r - l + 1)) % MOD;
			return;
		}

		int mid = l + (r - l) / 2;
		spread(i, l, r, aiml, aimr);

		if (aiml <= mid)
			_update1(i * 2, l, mid, aiml, aimr, val);
		if (aimr >= mid + 1)
			_update1(i * 2 + 1, mid + 1, r, aiml, aimr, val);
		d[i].val = (d[i * 2].val + d[i * 2 + 1].val) % MOD;
	}
	void _update2(int i, int l, int r, int aiml, int aimr, ll val)
	{
		if (aiml <= l && r <= aimr)
		{
			d[i].val = (d[i].val * val) % MOD;
			d[i].t1 = (d[i].t1 * val) % MOD;
			d[i].t2 = (d[i].t2 * val) % MOD;
			return;
		}

		int mid = l + (r - l) / 2;
		spread(i, l, r, aiml, aimr);

		if (aiml <= mid)
			_update2(i * 2, l, mid, aiml, aimr, val);
		if (aimr >= mid + 1)
			_update2(i * 2 + 1, mid + 1, r, aiml, aimr, val);
		d[i].val = (d[i * 2].val + d[i * 2 + 1].val) % MOD;
	}
public:
	ll getsum(int l, int r)
	{
		return _getsum(1, 1, n, l, r);
	}
	void update1(int l, int r, ll val)
	{
		_update1(1, 1, n, l, r, val);//加并挂标记
	}
	void update2(int l, int r, ll val)
	{
		_update2(1, 1, n, l, r, val);//加并挂标记
	}
	ST(vector<ll>arr)
	{
		a = arr;
		n = a.size() - 1;
		d = vector<node>(4*n);
		build_tree(1, 1, n);
	}
};