Statement
- 區間塗顏色
- 區間顏色數
Solution
\(O(\text{polysqrt})\)
略。
\(O(\text{polylog})\)
顏色段均攤有兩層含義：
- 隨機資料下：任意時刻的顏色段個數期望 \(O(\log n)\)
- 非隨機資料下：每次推平時訪問的顏色段個數均攤 \(O(n)\)
首先維護每個點 \(i\) 的 \(pre_i\)，一次詢問相當於二維偏序。
考慮單點修咋做，他對 \(pre\) 的修改是 \(O(1)\) 的，一次修改看成一次刪除 + 一次插入，可以三維偏序完成。
考慮這題咋做。
結論：進行所有區間修改後，\(pre\) 陣列的單點修改次數是 \(O(n+m)\) 的。
我們稱一個顏色段為一個節點，注意到如果一個節點整體賦上一個值，那麼只有節點第一個數、原先最後一個數的後繼、現在最後一個數的後繼的 \(pre\) 會被修改。
考慮 ODT 的過程，每次修改，我們先將兩端的節點分裂，然後刪除中間節點，再換成一個同一個節點。
分裂和更換的過程，就是刪除若干個節點，再新增至多三個節點。對 \(pre\) 陣列的修改次數和刪除的節點數同階。而每個節點至多刪除一次，我們新增的節點個數是 \(O(m)\) 的，初始的節點個數是 \(O(n)\) 的。因此，\(pre\) 陣列的單點修改次數是 \(O(n+m)\) 的。
既然這樣，我們就只需找到 \(pre\) 陣列被修改的位置和時間，然後按單點修改的方式做就好了！
怎麼找呢？其實就是上面複雜度分析那個過程。我們直接拿個 ODT 維護，然後每次修改就可以找出若干個可能被修改的節點，然後對這些節點求修改後的 \(pre\) 即可。怎麼求 \(pre\)？我們對每種顏色開個 ODT 即可。
Code
柯朵莉樹寫法是跟 251Sec 學的。
#include <bits/stdc++.h>
using namespace std;
#define rep(i, j, k) for (int i = (j); i <= (k); ++i)
#define reo(i, j, k) for (int i = (j); i >= (k); --i)
typedef long long ll;
const int N = 2e5 + 10, M = 2e6 + 10;
int n, m, a[N], pre[N], buc[N];
map<int, int> mp;
int btot;
struct Operations {
int pos, val, tim, xishu, id;
} Oper[M], tmp[M];
int optot, qtot, ans[N];
struct ODTNode {
int l, r, v;
bool operator< (const ODTNode& o) const {
return l < o.l;
}
};
struct ODT {
typedef set<ODTNode>::iterator iter;
set<ODTNode> tr, col[N];
iter Insert(int l, int r, int v) {
col[v].insert({l, r, v});
return tr.insert({l, r, v}).first;
}
void Delete(int l, int r, int v) {
col[v].erase({l, r, v});
tr.erase({l, r, v});
}
iter Split(int p) {
iter it = tr.lower_bound({p, 0, 0});
if (it != tr.end() && it->l == p) return it;
--it;
int l = it->l, r = it->r, v = it->v;
Delete(l, r, v);
Insert(l, p - 1, v);
return Insert(p, r, v);
}
int Pre(int p) {
iter it = --tr.upper_bound({p, 0, 0});
if (it->l != p) return p - 1;
else {
int v = it->v;
it = col[v].lower_bound({p, 0, 0});
if (it != col[v].begin()) return (--it)->r;
else return 0;
}
}
int Suf(int p) {
iter it = --tr.upper_bound({p, 0, 0});
if (it->r != p) return p + 1;
else {
int l = it->l, v = it->v;
it = col[v].lower_bound({l + 1, 0, 0});
if (it != col[v].end()) return it->l;
else return n + 1;
}
}
void Assign(int l, int r, int v, int t) {
iter itr = Split(r + 1), itl = Split(l);
vector<int> vec;
for (iter it = itl; it != itr; ++it) {
int pl = it->l, pr = it->r, pv = it->v, x = Suf(pr);
vec.push_back(pl);
if (x > r && x != n + 1) vec.push_back(x);
col[pv].erase(*it);
}
tr.erase(itl, itr);
Insert(l, r, v);
int x = Suf(r);
if (x != n + 1) vec.push_back(x);
for (int p : vec) {
Oper[++optot] = {p, pre[p], t, -1, 0};
Oper[++optot] = {p, pre[p] = Pre(p), t, 1, 0};
}
}
} odt;
struct BIT {
int sum[N];
BIT() {
memset(sum, 0, sizeof(sum));
}
void Upd(int x, int v) {
for (++x; x < N; x += x & -x) sum[x] += v;
}
int Qry(int x) {
int res = 0;
for (++x; x; x -= x & -x) res += sum[x];
return res;
}
} bit;
void CDQ(int l, int r) {
if (l == r) return;
int mid = (l + r) >> 1;
CDQ(l, mid), CDQ(mid + 1, r);
int pos = l;
rep(j, mid + 1, r) {
if (!Oper[j].id) continue;
while (pos <= mid && Oper[pos].pos <= Oper[j].pos) {
if (!Oper[pos].id) bit.Upd(Oper[pos].val, Oper[pos].xishu);
++pos;
}
ans[Oper[j].id] += Oper[j].xishu * bit.Qry(Oper[j].val);
}
rep(i, l, pos - 1) if (!Oper[i].id) bit.Upd(Oper[i].val, -Oper[i].xishu);
int tp = l;
for (int i = l, j = mid + 1; i <= mid || j <= r; )
if (i <= mid && (j > r || Oper[i].pos <= Oper[j].pos)) tmp[tp++] = Oper[i++];
else tmp[tp++] = Oper[j++];
rep(i, l, r) Oper[i] = tmp[i];
}
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
cin >> n >> m;
rep(i, 1, n) {
cin >> a[i];
if (!mp.count(a[i])) mp[a[i]] = ++btot;
a[i] = mp[a[i]];
pre[i] = buc[a[i]];
buc[a[i]] = i;
Oper[++optot] = {i, pre[i], 0, 1, 0};
odt.Insert(i, i, a[i]);
}
rep(i, 1, m) {
int op, l, r, x;
cin >> op >> l >> r;
if (op == 1) {
cin >> x;
if (!mp.count(x)) mp[x] = ++btot;
x = mp[x];
odt.Assign(l, r, x, i);
} else {
Oper[++optot] = {r, l - 1, i, 1, ++qtot};
Oper[++optot] = {l - 1, l - 1, i, -1, qtot};
}
}
CDQ(1, optot);
rep(i, 1, qtot) cout << ans[i] << '\n';
return 0;
}