「JOISC 2019 Day3」穿越時空 Bitaro-線段樹

Description

在河狸國，一條路上有 $N$ 座城市，依次編爲 $1\ldots N$ 號；連接城市 $i$ 和城市 $i+1$ 的那段路被稱爲 $i$ 號路。在河狸國，一天有 $10^9$ 秒，依次稱爲時刻 $0\ldots 10^9-1$。從城市 $i$ 沿路到達與之相鄰的城市——城市 $i-1$ 或城市 $i+1$ 需要 $1$ 個單位時間。$i$ 號路每天在時刻 $L_i$ 到時刻 $R_i$ 之間開放通行。具體說來，爲了通過 $i$ 號道路，我們必須在滿足 $L_i\le x\le R_i-1$ 的時刻 $x$ 從城市 $i$ 或城市 $i+1$ 出發，在 $x+1$ 時刻到達另一城市。

Bitaro 原本是一位住在河狸國的普通河狸，然而，爲了改掉自己遲到的壞習慣，他最終獲得了穿越時空的技能。每次使用這個技能，他能回到一秒前。但他不能回到前一天：也就是說，如果他在 $0$ 時刻與 $1$ 時刻之間使用技能，他只能回到這一天的 $0$ 時刻。他只能在城市裏使用這個技能。使用這個技能不會改變他的位置。

穿越時空會讓 Birato 變累。爲了找到能從一個城市到另一個城市且使用技能次數最少的方法，他決定進行一個 $Q$ 步的想象試驗。第 $j$ 步實驗是以下兩種情況之一：

• 改變 $P_j$ 號道路的開放時間，改後 $P_j$ 號道路在時刻 $S_j$ 到時刻 $E_j$ 開放通行；
• 假設時刻 $B_j$ 他在城市 $A_j$，然後計算在這一天的時刻 $D_j$ 他要到達城市 $C_j$ 的話至少需要使用多少次技能。

他很想知道實驗結果。

$n \leq 3 \times 10^5$

Solution

JOI 的題好清新啊。

先只考慮從左到右的情況，從右到左把整個序列 $reverse$ 就行了。

有一個非常自然的想法是把題目放到座標系上。橫座標代表位置，縱座標代表時間。發下斜向的移動非常麻煩，考慮把涉及到第 $i$ 個點的時間全部減去 $i$，這樣移動時就會變成橫線。

ps.來自官方題解

考慮修改和查詢。可以發現對於臨近的兩個點 $i, i + 1$，設它們的時間區域分別是 $[a,b],[c,d]$。假設兩區間有交，那麼 $[i, i+1]$ 的時間區域可以看做 $[a,b],[c,d]$ 的交集。

如果無交，這段路徑可以表示爲一個三元組 $(a,b,c)$，意味着必須先把時間調到 $a$ 才能走進，然後出來時時間是 $b$，中間花費的時間是$c$。比如 $R_i < L_{i+1}$，那麼三元組爲 $(R_i,L_{i+1},0)$；如果 $L_i > R_{i+1}$，那麼三元組爲 $(L_i,R_{i+1},L_i-R_{i+1})$。

之後還要考慮三元組/二元組（區間）之間的合併，策略是一樣的，即能走就走，否則調時間。

合併顯然滿足結合率，線段樹維護即可。

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

typedef long long ll;
const int maxn = 3e5 + 5;

inline int gi()
{
	char c = getchar();
	while (c < '0' || c > '9') c = getchar();
	int sum = 0;
	while ('0' <= c && c <= '9') sum = sum * 10 + c - 48, c = getchar();
	return sum;
}

int n, q;
int l[maxn], r[maxn], op[maxn], a[maxn], b[maxn], c[maxn], d[maxn];
ll ans[maxn];

struct node
{
	int op, x, y;
	ll c;
} seq[maxn], val[maxn << 2];

node operator + (const node &a, const node &b)
{
	if (a.op) {
		if (b.op) return (node) {1, a.x, b.y, a.c + b.c + max(0, a.y - b.x)};
		else return (node) {1, a.x, max(b.x, min(b.y, a.y)), a.c + max(0, a.y - b.y)};
	} else {
		if (b.op) return (node) {1, min(a.y, max(a.x, b.x)), b.y, b.c + max(0, a.x - b.x)};
		else if (a.y < b.x) return (node) {1, a.y, b.x, 0};
		else if (a.x > b.y) return (node) {1, a.x, b.y, a.x - b.y};
		else return (node) {0, max(a.x, b.x), min(a.y, b.y), 0};
	}
}

#define mid ((l + r) >> 1)
#define lch (s << 1)
#define rch (s << 1 | 1)

void build(int s, int l, int r)
{
	if (l == r) return val[s] = seq[l], void();
	build(lch, l, mid);
	build(rch, mid + 1, r);
	val[s] = val[lch] + val[rch];
}

void modify(int s, int l, int r, int p, node v)
{
	if (l == r) return val[s] = v, void();
	if (p <= mid) modify(lch, l, mid, p, v);
	if (p >= mid + 1) modify(rch, mid + 1, r, p, v);
	val[s] = val[lch] + val[rch];
}

node query(int s, int l, int r, int ql, int qr)
{
	if (ql <= l && r <= qr) return val[s];
	if (qr <= mid) return query(lch, l, mid, ql, qr);
	else if (ql >= mid + 1) return query(rch, mid + 1, r, ql, qr);
	else return query(lch, l, mid, ql, qr) + query(rch, mid + 1, r, ql, qr);
}

void reverse()
{
	reverse(l + 1, l + n);
	reverse(r + 1, r + n);
	for (int i = 1; i <= q; ++i)
		if (op[i] == 1) a[i] = n - a[i];
		else a[i] = n + 1 - a[i], c[i] = n + 1 - c[i];
}

void solve()
{
	for (int i = 1; i < n; ++i) seq[i] = (node) {0, l[i] - i, r[i] - i - 1, 0};
	build(1, 1, n - 1);
	for (int i = 1; i <= q; ++i)
		if (op[i] == 1) modify(1, 1, n - 1, a[i], (node) {0, b[i] - a[i], c[i] - a[i] - 1, 0});
		else if (a[i] == c[i]) ans[i] = max(0, b[i] - d[i]);
		else if (a[i] < c[i]) ans[i] = ((node) {0, b[i] - a[i], b[i] - a[i], 0} + query(1, 1, n - 1, a[i], c[i] - 1) + (node) {d[i] - c[i], d[i] - c[i]}).c;
}

int main()
{
	n = gi(); q = gi();
	if (n == 1) {
		for (int i = 1; i <= q; ++i) {
			op[i] = gi(), a[i] = gi(), b[i] = gi(), c[i] = gi(), d[i] = op[i] == 2 ? gi() : 0;
			if (op[i] == 2) printf("%d\n", max(0, b[i] - d[i]));
		}
		return 0;
	}
	for (int i = 1; i < n; ++i) l[i] = gi(), r[i] = gi();
	for (int i = 1; i <= q; ++i) op[i] = gi(), a[i] = gi(), b[i] = gi(), c[i] = gi(), d[i] = op[i] == 2 ? gi() : 0;

	solve();
	reverse();
	solve();

	for (int i = 1; i <= q; ++i) if (op[i] == 2) printf("%lld\n", ans[i]);
	
	return 0;
}