洛谷 P4433 [COCI2009-2010#1] ALADIN

洛谷传送门

考虑一个前置问题：给定 \(a, b, n\)，求 \(\sum\limits_{i = 1}^{n} (ia \bmod b)\)。

根据 \(x \bmod y = x - y \left\lfloor\frac{x}{y}\right\rfloor\) 可以化简式子：

\[\sum\limits_{i = 1}^{n} (ia \bmod b) = \sum\limits_{i = 1}^n ia - b \sum\limits_{i = 1}^n \left\lfloor\frac{ia}{b}\right\rfloor \]

可以类欧计算。

考虑离散化后用线段树维护区间和，每个叶子结点代表离散化端点后相邻两点形成的区间。

区间修改时，给涉及到的点打形如 \((a, b, t)\) 的标记，表示这个点的和为 \(\sum\limits_{i = t}^{t + len - 1} (ia \bmod b)\)。下传是容易的。

时间复杂度 \(O(q \log q \log V)\)。

code

// Problem: P4433 [COCI2009-2010#1] ALADIN
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P4433
// Memory Limit: 64 MB
// Time Limit: 8000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
#define pb emplace_back
#define fst first
#define scd second
#define mkp make_pair
#define mems(a, x) memset((a), (x), sizeof(a))

using namespace std;
typedef long long ll;
typedef __int128 lll;
typedef double db;
typedef unsigned long long ull;
typedef long double ldb;
typedef pair<ll, ll> pii;

const int maxn = 100100;

ll n, m, lsh[maxn], tot;
struct wwh {
	ll op, l, r, a, b;
} qq[maxn];

struct node {
	lll cntx, cnty, sum;
	node(lll a = 0, lll b = 0, lll c = 0) : cntx(a), cnty(b), sum(c) {}
};

inline node operator + (const node &a, const node &b) {
	node res;
	res.cntx = a.cntx + b.cntx;
	res.cnty = a.cnty + b.cnty;
	res.sum = a.sum + b.sum + a.cnty * b.cntx;
	return res;
}

inline node qpow(node a, lll p) {
	node res;
	while (p) {
		if (p & 1) {
			res = res + a;
		}
		a = a + a;
		p >>= 1;
	}
	return res;
}

node solve(lll p, lll q, lll r, lll n, node a, node b) {
	if (!n) {
		return node();
	}
	if (p >= q) {
		return solve(p % q, q, r, n, a, qpow(a, p / q) + b);
	}
	lll cnt = (n * p + r) / q;
	if (!cnt) {
		return qpow(b, n);
	}
	return qpow(b, (q - r - 1) / p) + a + solve(q, p, (q - r - 1) % p, cnt - 1, b, a) + qpow(b, n - (q * cnt - r - 1) / p);
}

inline lll calc1(lll p, lll q, lll r, lll n) {
	node a(0, 1), b(1, 0);
	node ans = qpow(a, r / q) + solve(p, q, r % q, n, a, b);
	return ans.sum;
}

inline lll calc2(lll a, lll b, lll n) {
	lll s1 = n * (n + 1) / 2 * a;
	lll s2 = calc1(a, b, 0, n) * b;
	return s1 - s2;
}

inline lll calc2(lll a, lll b, lll l, lll r) {
	return calc2(a, b, r) - calc2(a, b, l - 1);
}

namespace SGT {
	struct node {
		ll a, b, t;
		node(ll x = 0, ll y = 0, ll z = 0) : a(x), b(y), t(z) {}
	} tag[maxn << 2];
	ll sum[maxn << 2];
	
	inline void pushup(int x) {
		sum[x] = sum[x << 1] + sum[x << 1 | 1];
	}
	
	inline void pushdown(int x, int l, int r) {
		if (!tag[x].b) {
			return;
		}
		int mid = (l + r) >> 1;
		sum[x << 1] = calc2(tag[x].a, tag[x].b, tag[x].t, tag[x].t + lsh[mid + 1] - lsh[l] - 1);
		sum[x << 1 | 1] = calc2(tag[x].a, tag[x].b, tag[x].t + lsh[mid + 1] - lsh[l], tag[x].t + lsh[r + 1] - lsh[l] - 1);
		tag[x << 1] = node(tag[x].a, tag[x].b, tag[x].t);
		tag[x << 1 | 1] = node(tag[x].a, tag[x].b, tag[x].t + lsh[mid + 1] - lsh[l]);
		tag[x] = node();
	}
	
	void update(int rt, int l, int r, int ql, int qr, ll a, ll b) {
		if (ql <= l && r <= qr) {
			tag[rt] = node(a, b, lsh[l] - lsh[ql] + 1);
			sum[rt] = calc2(a, b, lsh[l] - lsh[ql] + 1, lsh[r + 1] - lsh[ql]);
			return;
		}
		pushdown(rt, l, r);
		int mid = (l + r) >> 1;
		if (ql <= mid) {
			update(rt << 1, l, mid, ql, qr, a, b);
		}
		if (qr > mid) {
			update(rt << 1 | 1, mid + 1, r, ql, qr, a, b);
		}
		pushup(rt);
	}
	
	ll query(int rt, int l, int r, int ql, int qr) {
		if (ql <= l && r <= qr) {
			return sum[rt];
		}
		pushdown(rt, l, r);
		int mid = (l + r) >> 1;
		ll res = 0;
		if (ql <= mid) {
			res += query(rt << 1, l, mid, ql, qr);
		}
		if (qr > mid) {
			res += query(rt << 1 | 1, mid + 1, r, ql, qr);
		}
		return res;
	}
}

void solve() {
	scanf("%lld%lld", &n, &m);
	for (int i = 1; i <= m; ++i) {
		scanf("%lld%lld%lld", &qq[i].op, &qq[i].l, &qq[i].r);
		if (qq[i].op == 1) {
			scanf("%lld%lld", &qq[i].a, &qq[i].b);
		}
		lsh[++tot] = qq[i].l;
		lsh[++tot] = (++qq[i].r);
	}
	sort(lsh + 1, lsh + tot + 1);
	tot = unique(lsh + 1, lsh + tot + 1) - lsh - 1;
	for (int i = 1; i <= m; ++i) {
		qq[i].l = lower_bound(lsh + 1, lsh + tot + 1, qq[i].l) - lsh;
		qq[i].r = lower_bound(lsh + 1, lsh + tot + 1, qq[i].r) - lsh;
	}
	for (int i = 1; i <= m; ++i) {
		ll op = qq[i].op, l = qq[i].l, r = qq[i].r, a = qq[i].a, b = qq[i].b;
		if (op == 1) {
			SGT::update(1, 1, tot - 1, l, r - 1, a, b);
		} else {
			printf("%lld\n", SGT::query(1, 1, tot - 1, l, r - 1));
		}
	}
}

int main() {
	int T = 1;
	// scanf("%d", &T);
	while (T--) {
		solve();
	}
	return 0;
}