LOJ 6029「雅礼集训 2017 Day1」市场 Solution

Description

给定序列 $a=(a_0,a_1,\cdots ,a_{n-1})$，有 $m$ 个操作分三种：

• $\mathrm{add}(l,r,k)$：对每个 $i\in [l,r]$ 执行 $a_i\leftarrow a_i+v$.
• $\mathrm{divide}(l,r,v)$：对每个 $i\in [l,r]$ 执行 $a_i\leftarrow \lfloor \frac{a_i}{v}\rfloor$.
• $\mathrm{qmin}(l,r)$：求 $\underset{i=l}{\overset{r}{\min }}{a}_i$.
• $\mathrm{qsum}(l,r)$：求 $\sum _{i=l}^r{a}_i$.

Limitations

$1\le n,m\le 10^5$
$0\le l\le r<n$
$|c|\le 10^4$
$2\le d\le 10^9$
$2\text{s},256\text{MB}$

Solution

由于除法带下取整，无法合并标记，但一个区间 $\mathrm{divide}$ 上 $O(\log V)$ 次，最大值就会变成 $1$，所以可以暴力做.
但 $\mathrm{add}$ 操作会让复杂度假掉，不过如果 $\text{max}-\lfloor \frac{\text{max}}{v}\rfloor =\text{min}-\lfloor \frac{\text{min}}{v}\rfloor$，那么这个区间每个数的变化量一致，可以直接打加标记.
时间复杂度 $O(m\log n\log V)$.
有几个注意点：

• C++ 除法向 $0$ 取整，但我们需要向下取整，需要转化.
• 下标从 $0$ 开始.

Code

$3.7\text{KB},1.13\text{s},6.9\text{MB}\text{(in total, C++20 with O2)}$

#include <bits/stdc++.h>
using namespace std;

using i64 = long long;
using ui64 = unsigned long long;
using i128 = __int128;
using ui128 = unsigned __int128;
using f4 = float;
using f8 = double;
using f16 = long double;

template<class T>
bool chmax(T &a, const T &b){
	if(a < b){ a = b; return true; }
	return false;
}

template<class T>
bool chmin(T &a, const T &b){
	if(a > b){ a = b; return true; }
	return false;
}

constexpr int inf = 2e9;
inline int fdiv(int a, int b) { 
    if (a >= 0) return a / b;
	else return (a - b + 1) / b;
}

namespace seg_tree {
	struct Node {
		int l, r;
		int max, min, tag;
		i64 sum;
	};
	
	inline int ls(int u) { return 2 * u + 1; }
	inline int rs(int u) { return 2 * u + 2; }
	
	struct SegTree {
		vector<Node> tr;
		inline SegTree() {}
		inline SegTree(const vector<int>& a) {
			const int n = a.size();
			tr.resize(n << 1);
			build(0, 0, n - 1, a);
		}
		
		inline void pushup(int u, int mid) {
			tr[u].max = std::max(tr[ls(mid)].max, tr[rs(mid)].max);
			tr[u].min = std::min(tr[ls(mid)].min, tr[rs(mid)].min);
			tr[u].sum = tr[ls(mid)].sum + tr[rs(mid)].sum;
		}
		
		inline void apply(int u, int tag) {
			tr[u].max += tag;
			tr[u].min += tag;
			tr[u].tag += tag;
			tr[u].sum += 1LL * tag * (tr[u].r - tr[u].l + 1);
		}
		
		inline void pushdown(int u, int mid) {
			if (tr[u].tag) {
				apply(ls(mid), tr[u].tag);
				apply(rs(mid), tr[u].tag);
				tr[u].tag = 0;
			}
		}
		
		void build(int u, int l, int r, const vector<int>& a) {
			tr[u].l = l, tr[u].r = r;
			if (l == r) return (void)(tr[u].sum = tr[u].max = tr[u].min = a[l]);
			const int mid = (l + r) >> 1;
			build(ls(mid), l, mid, a);
			build(rs(mid), mid + 1, r, a);
			pushup(u, mid);
		}
		
		void add(int u, int l, int r, int k) {
			if (l <= tr[u].l && tr[u].r <= r) return apply(u, k);
			const int mid = (tr[u].l + tr[u].r) >> 1;
			pushdown(u, mid);
			if (l <= mid) add(ls(mid), l, r, k);
			if (r > mid) add(rs(mid), l, r, k);
			pushup(u, mid);
		}
		
		void divide(int u, int l, int r, int k) {
			if (l <= tr[u].l && tr[u].r <= r) {
				const int dmax = fdiv(tr[u].max, k) - tr[u].max;
				const int dmin = fdiv(tr[u].min, k) - tr[u].min;
				if (dmax == dmin) return apply(u, dmax);
			}
			const int mid = (tr[u].l + tr[u].r) >> 1;
			pushdown(u, mid);
			if (l <= mid) divide(ls(mid), l, r, k);
			if (r > mid) divide(rs(mid), l, r, k);
			pushup(u, mid);
		}
		
		int qmin(int u, int l, int r) {
			if (l <= tr[u].l && tr[u].r <= r) return tr[u].min;
			const int mid = (tr[u].l + tr[u].r) >> 1;
			int res = inf;
			pushdown(u, mid);
			if (l <= mid) res = std::min(res, qmin(ls(mid), l, r));
			if (r > mid) res = std::min(res, qmin(rs(mid), l, r));
			return res;
		}
		
		i64 qsum(int u, int l, int r) {
			if (l <= tr[u].l && tr[u].r <= r) return tr[u].sum;
			const int mid = (tr[u].l + tr[u].r) >> 1;
			i64 res = 0;
			pushdown(u, mid);
			if (l <= mid) res += qsum(ls(mid), l, r);
			if (r > mid) res += qsum(rs(mid), l, r);
			return res;
		}
		
		inline void range_add(int l, int r, int v) { add(0, l, r, v); }
		inline void range_div(int l, int r, int v) { divide(0, l, r, v); }
		inline int range_min(int l, int r) { return qmin(0, l, r); }
		inline i64 range_sum(int l, int r) { return qsum(0, l, r); }
	};
}
using seg_tree::SegTree;

signed main() {
	ios::sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	
	int n, m;
	scanf("%d %d", &n, &m);
	vector<int> a(n);
	for (int i = 0; i < n; i++) scanf("%d", &a[i]);
	
	SegTree sgt(a);
	for (int i = 0, op, l, r, v; i < m; i++) {
		scanf("%d %d %d", &op, &l, &r);
		if (op == 1) scanf("%d", &v), sgt.range_add(l, r, v);
		if (op == 2) scanf("%d", &v), sgt.range_div(l, r, v);
		if (op == 3) printf("%d\n", sgt.range_min(l, r));
		if (op == 4) printf("%lld\n", sgt.range_sum(l, r));
	}
	return 0;
}