進階資結
\(225\)賴泓安
IOIC2023進階資結課程
去年資讀簡報
給一個長為\(N\)的序列\(A\)，有\(Q\)筆詢問
每次輸出\([l,r]\)之間的絕對眾數，不存在則輸出\(0\)
\(N,Q,a_i \leq 5\cdot10^5\)
絕對眾數：出現數目嚴格大於所有數字的一半
假設只有一筆詢問
我們做個神奇操作
紀錄一開始的數字\(x = a_l\)，並給它一個生命值\(hp = 1\)
然後往右掃
如果遇到的數字\(a_i = x\)，\(hp\)++，否則\(hp\)--
若\(hp\)已經\(=0\)，則設\(x = a_i\)，\(hp\)重設為\(1\)
只有做完後留下來的\(x\)有可能是答案！
可以線性 或 預處理+二分搜驗
注意到，我們把兩個相異元素\(x,y\)一起去除時
並不會影響絕對眾數的地位
如果\(x,y\)都不是絕對眾數，那沒有差。
如果其中一個是絕對眾數（假設有\(k\)個）
原本：\(k > \frac{N}{2}\)
刪除後的比例：\( (k-1):(N-2) \)
\((k-1) > \frac{N-2}{2} \)仍然成立
用線段樹維護區間內的\(x和hp\)
對每個詢問\([l,r]\)，各個樹上的子區間是可以合併的
所以能夠得到最終留下來的\(x\)
再二分搜確認是否為答案
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl '\n'
#define pii pair<int,int>
int arr[500005];
vector <pair<int,int> > sg;
pii init(int l, int r, int node) {
if (l == r) {
sg[node].first = arr[l];
sg[node].second = 1;
return sg[node];
}
int mid = (l+r)>>1;
pii lp = init(l,mid,node<<1);
pii rp = init(mid+1,r,(node<<1)+1);
if (lp.first == rp.first) {
sg[node].first = lp.first;
sg[node].second = lp.second+rp.second;
} else {
if (lp.second >= rp.second) {
sg[node].first = lp.first;
sg[node].second = lp.second-rp.second;
} else {
sg[node].first = rp.first;
sg[node].second = rp.second-lp.second;
}
}
return sg[node];
}
pii query(int ql, int qr, int l, int r, int node) {
if (ql <= l && r <= qr) {
return sg[node];
}
int mid = (l+r)>>1;
if (qr <= mid) {
return query(ql,qr,l,mid,node<<1);
}
if (ql > mid) {
return query(ql,qr,mid+1,r,(node<<1)+1);
}
pii lp = query(ql,qr,l,mid,node<<1);
pii rp = query(ql,qr,mid+1,r,(node<<1)+1);
pii ret;
if (lp.first == rp.first) {
ret.first = lp.first;
ret.second = lp.second+rp.second;
} else {
if (lp.second >= rp.second) {
ret.first = lp.first;
ret.second = lp.second-rp.second;
} else {
ret.first = rp.first;
ret.second = rp.second-lp.second;
}
}
return ret;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, q;
cin>>n>>q;
vector <vector<int> > pos(500005);
sg.resize(n<<2);
for (int i = 1; i <= n; ++i) {
cin>>arr[i];
pos[arr[i]].push_back(i);
}
init(1,n,1);
while(q--) {
int l, r;
cin>>l>>r;
pii pa = query(l,r,1,n,1);
auto al = lower_bound(pos[pa.first].begin(),pos[pa.first].end(),l);
auto ar = upper_bound(pos[pa.first].begin(),pos[pa.first].end(),r);
int count = ar-al;
if (count > ((r-l+1)>>1)) {
cout<<pa.first<<endl;
} else {
cout<<0<<endl;
}
}
return 0;
}給定一張原本無邊的圖，有三種操作
\(1.\)連接一條\(u,v\)之間邊權\(w\)的邊
\(2.\)連接所有\([l,r]\)到\(v\)之間邊權\(w\)的邊
\(3.\)連接\(u\)到所有\([l,r]\)之間邊權\(w\)的邊
最後求單點源最短路
\(N,Q \leq 10^5, w \leq 10^9\)
最短路顯然是要Dijkstra
每個線段樹上的節點
都代表某段連續區間的所有點
反過來說，針對給定的一段連續區間
我們可以將它分解成線段樹上的最多\(logN\)個節點
先建兩棵線段樹，分別作為入度和出度使用
入度那棵往子節點連無權邊
出度那棵往父節點連無權邊
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8
\(1.\)區間連到點\(v\)：
從負責出度的那棵線段樹上，找到一些節點代表當前區間
從這些節點連邊到代表\(v\)的葉節點
\(2.\)點\(u\)連到區間：
從負責入度的那棵線段樹上，找到一些節點代表當前區間
由代表\(u\)的葉節點連邊回去
1
2
3
4
5
6
7
8
2 -> [1,6]
8 -> [5,7]
1
2
3
4
5
6
7
8
[1,2] -> 3
[1,5] -> 7
每次操作最多連\(log N\)條邊
操作複雜度\(O(Q log N)\)
總節點數會是\(O(N)\)的
最後跑一遍Dijsktra
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair<int,int>
#define p_q priority_queue
#define endl '\n'
#define pb push_back
#define mid ((l+r)>>1)
#define int ll
int mpk;
vector<vector< pii > > g;
struct SEG{
int sz, t;
void setedge(int l, int r, int p) {
if (l == r) {
if (t) g[p+mpk].pb({(p>>1)+mpk,0});
else {
g[p].pb({p+mpk,0});
g[p+mpk].pb({p,0});
}
return;
}
setedge(l,mid,p<<1);
setedge(mid+1,r,p<<1|1);
if (!t) {
g[p].pb({p<<1,0});
g[p].pb({p<<1|1,0});
} else if (p != 1) {
g[p+mpk].pb({(p>>1)+mpk,0});
}
}
void init(int _n,int _t) {
sz = _n;
t = _t;
setedge(1,_n,1);
}
int find_node(int tar) {
int l = 1, r = sz, p = 1;
while(l != r) {
p <<= 1;
if (tar <= mid) r = mid;
else {
l = mid+1;
p++;
}
}
return t?(p+mpk):p;
}
void add(int l, int r, int p, int v, int ql, int qr, int w) {
if (ql <= l && r <= qr) {
if (!t) g[find_node(v)].pb({p,w});
else g[p+mpk].pb({find_node(v),w});
return;
}
if (qr <= mid) add(l,mid,p<<1,v,ql,qr,w);
else if (ql > mid) add(mid+1,r,p<<1|1,v,ql,qr,w);
else {
add(l,mid,p<<1,v,ql,qr,w);
add(mid+1,r,p<<1|1,v,ql,qr,w);
}
}
} seg[2];
signed main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, q, s;
cin>>n>>q>>s;
mpk = 4*n;
g.resize(2*mpk+5);
seg[0].init(n,0), seg[1].init(n,1);
while(q--) {
int c, v, l, r, w;
cin>>c>>v;
if (c == 1) {
cin>>l>>w;
seg[0].add(1,n,1,v,l,l,w);
} else if (c == 2) {
cin>>l>>r>>w;
seg[0].add(1,n,1,v,l,r,w);
} else {
cin>>l>>r>>w;
seg[1].add(1,n,1,v,l,r,w);
}
}
vector<int> dis(2*mpk+5,2e18), vis(2*mpk+5,0);
dis[seg[0].find_node(s)] = 0;
priority_queue< pii,vector< pii >,greater< pii > > pq;
pq.push({0,seg[0].find_node(s)});
while(!pq.empty()) {
pii cur = pq.top();
pq.pop();
if (vis[cur.second]) continue;
vis[cur.second] = 1;
for (auto [u,w] : g[cur.second]) {
if (dis[u] >= dis[cur.second]+w) {
dis[u] = dis[cur.second]+w;
pq.push({dis[u],u});
}
}
}
for (int i = 1; i <= n; ++i) {
if (i != 1) cout<<' ';
int ans = min(dis[seg[0].find_node(i)],dis[seg[1].find_node(i)]);
if (ans >= 2e18) cout<<-1;
else cout<<ans;
}
cout<<endl;
return 0;
}
顧名思義
跟值域線段樹差不多的概念
但這次我們以時間為Index開線段樹
給一張圖（\(N\)點\(M\)邊）
有一些加邊或刪邊操作
每次操作完問連通塊個數
\(N \leq 5\)x\(10^5\), \(M+Q \leq 5\)x\(10^5\)
說白一點
DSU的每次加邊操作
其實就是修改一個陣列上的某些值
進一步想，一使用啟發式合併時
每次加邊，陣列上最多只會有一個值被改變
在使用啟發式合併的狀況下
如果對DSU的操作只有回到上一步?
我們用一個stack紀錄每次加邊的時候誰被改到
每次的Undo操作
我們只需要把剛剛加邊時改到的值改回來
維護這個DSU的新增和刪除操作就很容易了吧
每條邊都會有一段存在的時間
我們可以把它拆成\(O(logN)\)個節點標在樹上
然後對線段樹DFS
1
2
3
4
5
6
7
8
Time:
+
+
+
+
-
-
-
+
+
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair<int,int>
#define p_q priority_queue
#define endl '\n'
#define pb push_back
#define mid ((l+r)>>1)
struct DSU{
vector<int> bs, sz;
vector< pii > hsp;
vector<int> num;
int cnt;
void init(int _n) {
bs.assign(_n+5,0);
sz.assign(_n+5,1);
num.clear(), hsp.clear();
cnt = _n;
for (int i = 1; i <= _n; ++i) bs[i] = i;
}
int find(int p) {
return (p == bs[p])?p:find(bs[p]);
}
void add(int u, int v) {
int a = find(u), b = find(v);
if (a == b) {
hsp.pb({0,0});
num.pb(0);
return;
}
if (sz[a] < sz[b]) swap(a,b);
bs[b] = a;
num.pb(b);
hsp.pb({a,sz[a]});
sz[a] += sz[b];
cnt--;
}
void undo() {
if (num.back()) {
sz[hsp.back().first] = hsp.back().second;
bs[num.back()] = num.back();
cnt++;
}
num.pop_back();
hsp.pop_back();
}
} dsu;
struct SEG{
vector<vector< pii > > a;
void init(int _n) {
a.assign(_n<<2,vector< pii >());
}
void mdf(int l, int r, int p, int ql, int qr, int u, int v) {
if (ql <= l && r <= qr) {
a[p].pb({u,v});
return;
}
if (ql > mid) mdf(mid+1,r,p<<1|1,ql,qr,u,v);
else if (qr <= mid) mdf(l,mid,p<<1,ql,qr,u,v);
else {
mdf(mid+1,r,p<<1|1,ql,qr,u,v);
mdf(l,mid,p<<1,ql,qr,u,v);
}
}
void dfs(int l, int r, int p) {
for (auto [u,v] : a[p]) dsu.add(u,v);
if (l == r) {
if (l) cout<<dsu.cnt<<endl;
for (int i = 0; i < a[p].size(); ++i) dsu.undo();
return;
}
dfs(l,mid,p<<1);
dfs(mid+1,r,p<<1|1);
for (int i = 0; i < a[p].size(); ++i) dsu.undo();
}
} seg;
void slv() {
int n, m, q;
cin>>n>>m>>q;
dsu.init(n);
int a, b;
map< pii,pii > mp;
while(m--) {
cin>>a>>b;
a++, b++;
if (a > b) swap(a,b);
mp[{a,b}].second++;
}
char c;
seg.init(q);
for (int i = 1; i <= q; ++i) {
cin>>c>>a>>b;
a++, b++;
if (a > b) swap(a,b);
if (c == 'N') {
if (!mp.count({a,b}) || !mp[{a,b}].second) mp[{a,b}].first = i;
mp[{a,b}].second++;
} else {
if (--mp[{a,b}].second == 0) {
seg.mdf(0,q,1,mp[{a,b}].first,i-1,a,b);
}
}
}
for (auto it : mp) {
if (!it.second.second) continue;
seg.mdf(0,q,1,it.second.first,q,it.first.first,it.first.second);
}
seg.dfs(0,q,1);
}
signed main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t; cin>>t;
while(t--) {
slv();
}
return 0;
}
例如李超線段樹
講師可能也不太會
就是要拆開出題者的包裝
看出題目真正要你處理的
有\(N\)個學生（編號\(1\)~\(N\)）由左而右排成一列
現在你要給每個學生一個介於\(1\)~\(N\)的成績
須符合下列條件：
1.由左而右，成績非嚴格遞增
2.學生編號遞增時，成績非嚴格遞增
有\(Q\)筆操作，每筆操作會交換兩位學生的位置
每次操作後輸出分派的成績最多可以有幾種數字
\(N \leq 10^6, Q \leq 3 \cdot10^5\)
學生排列：\([2,3,1,5,4,7,6]\)
一組合法排列：\([1,1,1,2,2,3,3]\)
＊有三個不同成績
好像有什麼類似環的結構耶
環的個數代表最多能放的數字種類
觀察相鄰兩人\(u,v\)（左與右）
若\(u > v\)，則\([u,v]\)的分數必須一樣
這可以想像成
\([u,v)\)這些人都被\(v\)給控制住了
所以我們的任務變成
要找有多少自由的人
對每組相鄰且\(u > v\)的\(u,v\)
我們對\([u,v)\)做區間加值
最後看有幾個\(0\)就是答案
（\(0\)一定是最小值，所以這等價詢問最小值個數）
可以用類似矩形覆蓋面積的線段樹維護
就當成先刪除再新增就好了
總複雜度：\(O(NlogN+QlogN)\)
有\(HW\)個座位，安排成\(H\)個橫列和\(W\)個直行。
橫列編號為\(0\)到\(H-1\)，直行編號為\(0\)到\(W-1\)。
你邀請了\(HW\)位選手，編號為\(0\)到\(HW-1\)，
你有一張座位圖，把選手\(i\)原先都有獨特的座位
座位當中，一個面積為\(k\)的長方形區域為美麗的
表示這個長方形中的選手編號是\(0\)到\(k-1\)
一張座位圖的美麗程度即為座位圖中所能找到的美麗長方形個數
接著會有\(Q\)筆操作
每次將兩位選手交換位置
請在每次更新過後
輸出當下座位表的美麗程度
我們可以先觀察看看座位為一直線的狀態
先假設所有座位一開始都沒人（記為白色）
然後讓選手一編號入座（該位置改為黑色）
所以我們的任務變成
找有多少時間點，黑色的位置是一段連續區間
符合要求：
不符合要求：
觀察：當一黑一白的1x2方格數恰為2時，即符合條件
我們可以先處理每個1x2方格會維持一黑一白的時間區間
假設該方格上的編號為\(L,R (L < R)\)
則其為黑白狀態的時間為\([L,R)\)
我們可以想像這是一個區間加值
詢問的時候就是看有多少個時間點\(=2\)
另外，只要我們塗上第一個黑色之後
一黑一白的方格一定會\(\geq2\)
所以我們詢問的會是最小值的個數
修改的的話當作刪除再新增處理即可
滿足黑色區域為一整塊長方形的條件為
符合
不符合
建樹：\(O(HW)\)
修改與詢問：\(O(QlogHW)\)
總共：\(O(HW+QlogHW)\)
吉如一線段樹
有一個序列\(A\)，長度為\(N\)
支援\(Q\)次下列兩種操作
1.詢問\([l,r]\)的區間和
2.把\([l,r]\)所有元素開根號
\(N,Q \leq 3\cdot10^5, a_i \leq 10^{12}\)
我們沒有辦法如往常那樣
隨便打個懶標說
我要把這個區間開根號
題目沒有把值變大的操作
開根號對某個數字\(C\)來說
最多只要\(O(loglogC)\)次
它就會變成\(1\)了
如果一個要被開根號的區間都已經是\(1\)
那我們不用理他
否則就暴力再遞迴下去
這樣最多也只會多暴力\(O(loglogC)\)次
總複雜度：\(O(QlogN+NlogNloglogC)\)
維護長度為\(N\)的序列\(A\)，
支援\(Q\)次下列3種操作
\(N,Q \leq 10^6, a_i \leq 10^{18}\)
\(a_i = min(a_i,x)\)做了什麼？
把區間內大於\(x\)的數字都變成\(x\)
其他的都不改變
如果區間內比\(x\)大的那些數字只有一種
那隨便就很好做
1.最大值 \(mx\)
2.最大值有幾個 \(cnt\)
3.嚴格次大值 \(snd\)
4.區間和 \(sum\)
5.懶人標記 \(tg\)
修改時 \(x \geq mx\)
很顯然我們什麼都不用做
修改時 \(snd < x < mx\)
修改\(mx = x\)
另外再打個懶標就好了
修改時 \(x \leq snd\)
我們好像在當前節點什麼也做不了？
那直接遞迴下去試試
詢問複雜度和一般線段樹都一樣
\(x > snd\)時也時間也不會爆炸
問題在暴力遞迴的部份
假設\(D(p)\)代表節點\(p\)內數字的種類
如果我們需要暴力做
表示有兩種以上的數字\(\geq x\)
然後修改完後他們都會變\(x\)
所以所有節點的\(D(p)\)的和
其實就是當\(ql \leq l \)且\( r \leq qr\)時
還需要暴力操作的上限
如果修改區間完整包含\(p\)
操作後\(D(p)\)至少會\(-1\)
如果不完全包含：
對於這樣的一個區間\(v\)
\(D(v)\)最多也只會\(+1\)
同時這種節點的數量是\(O(logN)\)量級的
增加的複雜度上限：\(O((N+Q)logN)\)
同樣的區間問題
但額外加了區間加值的操作
\(N,Q \leq 3 \cdot 10^5\)
一次區間加值
就可能造成數字種類增加\(O(n)\)量級
好像酶辦法做了
其實還是可以！
我們把\(D(p)\)的定義
重新改成以\(p\)為根的子樹中
節點上\(mx\)與\(mx_p\)不同的節點數
對一個遞迴終止的節點\(u\)來說
\(u\)上某節點的\(mx\)可能從與\(mx_p\)相同變相異
這樣對所有節點的\(D\)會增加\(O(logN)\)
整筆操作下來\(\Sigma D\)增加的量級是\(O(log^2N)\)
首先遞迴終止的節點會有\(O(logN)\)個
這件事代表我往下把某些
\(mx\)與\(mx_p\)不同的節點改成\(mx_p\)
這其實是消耗\(D(p)\)的
所以單就區間取\(min\)而言
對\(\Sigma D\)的貢獻是\(O(Qlog^2N)\)
遞迴終止的節點一樣會有\(O(logN)\)個
每個終止節點的子樹中，\(mx\)都會一起增加
最差的情況就是這\(O(logN)\)個節點都對\(\Sigma D\)有貢獻
另外走下來有一些沒完全覆蓋的節點
增加的\(D\)也是\(O(logN)\)
根據剛剛的分析
總複雜度會是\(O(NlogN+Qlog^2N)\)
但聽說跑起來非常快
可能跟一個\(log\)差不多
其實吉如一線段樹比起特定的資料結構
更算是一種新的概念
我們只是修改了線段樹上遞迴終止的條件
只要確保暴力造成的複雜度可以接受
那就是可以用的解法