離線算法

\[225\]賴泓安

自我介紹一下

建中\(225\)

我叫賴泓安

\(Handle:ancuber1031\)或類似的

\(Reference\)

謝一學長的簡報

OI Wiki

等等這個顏色的是題目連結

Abstract

先看看今天要幹麻

  • 莫隊算法
  • 整體二分搜
  • CDQ分治
  • Tarjan求LCA

我覺得code的template好醜

算法概念簡介

什麼是離線?

離線的相反是什麼?

當然就是在線啊

阿在線又是啥?

簡單來講就是秒讀秒回

問題一丟出來

你就馬上回答

比較:

在線:

每當輸入一個詢問,就馬上輸出結果

 

離線:

一次吃完所有詢問,

經過一些操作後求解,再全部輸出

普通莫隊

應該是分塊的東西

莫隊概念

考慮一個區間詢問的問題,假設\([l,r]\)的答案是\(ans(l,r)\)

如果對於\(ans(l-1,r),ans(l,r+1),ans(l+1,r),ans(l,r-1)\)

可以有效率的從\(ans(l,r)\)轉移

利用分塊的概念排序詢問

然後暴力轉移每筆詢問

莫隊作法

選定每塊大小為\(k\)

詢問左界依照所在的塊排序

同一塊內的詢問以右界大小排序

掃過排序好的詢問

每筆詢問都從上一塊暴力轉移

(一步步移動左右界)

複雜度

轉移複雜度\(O(P)\),塊數為\(S\),共有\(\frac{N}{k}\)塊

對於左界

在同一塊中的尋問每個最多移動\(k\)次,換塊總次數是\(N\)次

左界複雜度\(O(kQ+N)\)

右界則是塊數x\(N\),複雜度\(O(N \frac{N}{k})\)

總複雜度\(O((kQ+N+\frac{N^2}{k})P)\)

取最小:\(O(PN \sqrt{Q})\),此時\(k = \frac{N}{\sqrt{Q}}\)

Code

#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector,fast-math")
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define ull unsigned long long
#define endl '\n'
#define pii pair<int,int>
#define pll pair<ll,ll>
#define p_q priority_queue

int n, Q, k;
int l = 1, r = 0;
int cur = 0;
vector<int> a;
vector<int> cnt(1e5+5,0), am(1e5+5,0);

struct query{
    int ql, qr, id;
    bool operator<(query b) {
        if (ql/k == b.ql/k) return qr < b.qr;
        return ql/k < b.ql/k;
    }
};

void sub(int v) {
    am[cnt[v]]--;
    cnt[v]--;
    am[cnt[v]]++;
    if (cur==cnt[v]+1 && am[cnt[v]+1]==0) cur = cnt[v];
}

void add(int v) {
    am[cnt[v]]--;
    cnt[v]++;
    am[cnt[v]]++;
    cur = max(cur,cnt[v]);
}

int main() {
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin>>n>>Q;
    k = n/sqrt(Q);
    a.resize(n+1);
    vector<query> q(n);
    for (int i = 1; i <= n; ++i) cin>>a[i];
    for (int i = 0; i < Q; ++i) {
        cin>>q[i].ql>>q[i].qr;
        q[i].id = i;
    }
    sort(q.begin(),q.end());
    vector<int> ans(Q);
    am[0] = n;
    for (auto i : q) {
        while (r < i.qr) add(a[++r]);
        while (r > i.qr) sub(a[r--]);
        while (l < i.ql) sub(a[l++]);
        while (l > i.ql) add(a[--l]);
        ans[i.id] = cur;
    }
    for (int i = 0; i < Q; ++i) {
        cout<<ans[i]<<endl;
    }
    return 0;
}

\(Hint:\)壓常是個好東西:)

Code

#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

const int maxn = 2e5;

int n, Q, k, a, cnt = 0;
int arr[maxn+5], ans[maxn+5], num[maxn+5] = {0};
map<int,int> mp;

struct Query{
    int l, r, id;
    bool operator<(Query b) {
        if (l/k == b.l/k) return r < b.r;
        return l/k < b.l/k;
    }
} q[maxn+5];

inline void add(int p) {
    if (num[arr[p]]++ == 0) cnt++;
}

inline void sub(int p) {
    if (--num[arr[p]] == 0) cnt--;
}

signed main() {
    scanf("%d%d",&n,&Q);
    k = n/sqrt(Q);
    for (int i = 1; i <= n; ++i) {
        scanf("%d",&a);
        if (mp.find(a) != mp.end()) arr[i] = mp[a];
        else arr[i] = mp[a] = i;
    }
    for (int i = 1; i <= Q; ++i) {
        scanf("%d%d",&q[i].l,&q[i].r);
        q[i].id = i;
    }
    sort(q+1,q+Q+1);
    int l = 1, r = 0, ql, qr;
    for (int i = 1; i <= Q; ++i) {
        ql = q[i].l, qr = q[i].r;
        while(l < ql) sub(l++);
        while(r > qr) sub(r--);
        while(l > ql) add(--l);
        while(r < qr) add(++r);
        ans[q[i].id] = cnt;
    }
    for (int i = 1; i <= Q; ++i) printf("%d\n",ans[i]);
    return 0;
}

帶修改莫隊

普通莫隊加上時間維度!

說明

我們原本假設的是\([l,r]\)的答案是\(ans(l,r)\)

現在我們加上一個\(time\)的維度,代表經過了幾次修改

 

\(ans(l,r,time)\)代表區間\([l,r]\)中,經歷過\(time\)次修改的答案

 

轉移概念跟普通莫隊一樣

怎麼排序呢?

直接看結論

選定每塊大小(結論:\(n^{\frac{2}{3}}\))

第一順位依照左界所在的塊排序

第二順位以右界所在的塊排序

第三順位以\(time\)排序

複雜度

左右端點的塊不變,\(time\)會向右單調,\(O(n)\)

左右端點改變,\(time\)最大移動\(O(n)\)

左右端點可能的塊各是\(n^{\frac{1}{3}}\)

總複雜度:\(n^{\frac{1}{3}} \cdot n^{\frac{1}{3}} \cdot n\)

\(O(n^{\frac{5}{3}})\)

所以很爛:)

跟\(n^2\)沒差多少阿其實

回滾莫隊

差不多是被砍斷一隻手的意思

說明

剛剛的普通莫隊我們可以進行加入和刪除的動作

但假設今天我們只能做其中一個操作時怎麼辦?

RMQ

拿RMQ問題舉例

我們如果要求多筆詢問區間的最小值

可以很簡單的\(O(1)\)拓展區間

但刪除卻沒有一個有效率的方法

當然我知道RMQ都砸線段樹

回滾莫隊

這時候回滾莫隊可以保證\(O(N \sqrt{Q})\)內求解

且只需要用到加入操作

實作

實作時我們分成三種\(Case\)處理

  1. \(l,r\)在同一個分塊內
  2. \(r\)和上一筆詢問位於同一塊中
  3. \(r\)和上一筆詢問位於不同塊中

\(l,r\)位於同一塊內

反正塊不會太大(\(\frac{N}{\sqrt{Q}}\))

如果所有詢問都長這樣頂多也就\(O(N\sqrt{Q})\)

遇到這種直接暴力掃過區間即可

\(r\)和上一詢問同塊

這時候\(l\)一定遞增,右界作法相同

我們只要把左界拉回下一塊的第一個位置

(對每一塊都維護一個左端點到右界的答案)

然後拓展回到\(r\)即可

\(r\)和上一詢問不同塊

把左界設為下一塊的第一個

右界設為這一塊的最後一個

然後照普通莫隊拓展

Code

#pragma GCC optimize("Ofast")
#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
 
int n, k, Q;
int mn = 1e9+5, cmin = 1e9+5;
int arr[200005];
int ans[200005];
 
struct Query{
    int ql, qr, id;
    bool operator<(Query b) {
        if (ql/k == b.ql/k) return qr < b.qr;
        return ql/k < b.ql/k;
    }
} q[200005];
 
signed main() {
    scanf("%d%d",&n,&Q);
    k = n/sqrt(Q);
    for (int i = 1; i <= n; ++i) cin>>arr[i];
    for (int i = 1; i <= Q; ++i) {
        scanf("%d%d",&q[i].ql,&q[i].qr);
        q[i].id = i;
    }
    sort(q+1,q+Q+1);
    int l = 1, r = 0, pre = -1;
    for (int i = 1; i <= Q; ++i) {
        int cl = q[i].ql, cr = q[i].qr;
        if (cl/k == cr/k) {
            mn = 1e9+5;
            for (int j = cl; j <= cr; ++j) mn = min(mn,arr[j]);
        } else if (cl/k == pre) {
            l = (cl/k)*k+k;
            while(r < cr) cmin = min(arr[++r],cmin);
            mn = cmin;
            while(l > cl) mn = min(mn,arr[--l]);
        } else {
            l = (cl/k)*k+k, r = (cl/k)*k+k-1;
            pre = (cl/k);
            cmin = mn = 1e9+5;
            while(r < cr) cmin = min(arr[++r],cmin);
            mn = cmin;
            while(l > cl) mn = min(mn,arr[--l]);
        }
        ans[q[i].id] = mn;
    }
    for (int i = 1; i <= Q; ++i) printf("%d\n",ans[i]);
    return 0;
}

整體二分

如果每筆詢問可以二分搜

但詢問太多,每次都二分搜一次會TLE

可以吃完詢問在一起二分!

一般二分

在給一長度為\(n\)之序列\(arr\),求其中第\(k\)小的數

數字值域為\(1\) ~ \(C\)

除了直接排序之外還有什麼辦法?

對值域區間二分搜,

算有幾個數字小於\(mid\)(設為\(m\))

則對於每次猜測\(mid\)而言

 

如果\(m_{mid} < k,l = mid\)

如果\(m_{mid} > k,r = mid\)

複雜度:\(O(n log C)\)

現在題目一樣,但我要多次詢問第\(k\)小

 

如果我每筆詢問都二分搜一次

複雜度:\(O(Qn log  C)\)

有點慢

不如我一次二分搜全部

具體怎麼做?

對於當前處理的詢問

都猜它們的答案是\(mid\),然後一樣算\(m_{mid}\)

如果詢問的答案應該等於或更小就丟左邊,否則丟右邊

到\(l == r\)的時候就是當前詢問的答案

對原陣列做一樣的左右丟的操作

最多二分\(log  C\)層,\(O(Q)\)把詢問分兩邊

總複雜度:\(O((Q+N)log  C)\)

Code

struct Query {int id, k;};

int ans[N];//the answer of the i-th query
int check(int x);

void solve(int l, int r, vector<Query> q) {
    if (l == r) {
        for (auto i : q) ans[i.id] = l;
        return;
    }
    int mid = (l+r)>>1;
    int c = check(mid);
    vector<Query> ql, qr;//part
    for (auto i : q) {
        if (i.k <= c) ql.push_back(i);
        else qr.push_back({i.id,i.k-c});//important
    }
    solve(l,mid,ql), solve(mid+1,r,qr);
    return;
}

多次求區間第k小

換個方式維護陣列

但為了能高效率維護前綴,這邊我們需要使用BIT

例如:\([2,7,1,8,2,8,5,7,4]\)

 

\(Query\):\([l,r,k]\)

1.\([1,4,1]\)

2.\([2,3,2]\)

3.\([1,5,5]\)

 

\(C = 10\), 當前\(mid = 5\)

\([2,7,1,8,2,8,5,7,4]\)

\(C = 10\), 當前\(mid = 5\)

 

\(array\):\([1,0,1,0,1,0,1,0,1]\)

\(Pre:[0,1,1,2,2,3,3,4,4,5]\)

1.\([1,4,1]\):\(2-0 >  1\),\(ans<mid\),丟左邊

2.\([2,3,2]\):\(2-1  <  2\),\(ans>mid\),丟右邊

3.\([1,5,5]\):\(5-0 = 5\),\(ans=mid\),丟左邊

多次求區間第k小,帶修改

當前詢問依照時間順序做

遇到修改就當作刪除再加入數字

然後根據當前\(mid\)改\(array\)的值

就會變成維護動態前綴和

複雜度

序列長\(N\),詢問數\(Q\),值域\(C\)

每層需要\(O((Q+N)logN)\)

全部需要\(O((Q+N)logNlogC)\)

例題:

Code

#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;

#define endl '\n'
#define pb push_back
#define int long long

struct BIT{
    vector<int> a;
    int sz = 0;
    void init(int _n) { 
        sz = _n;
        a.assign(_n+5,0); 
    }
    void add(int p, int v) {
        while(p <= sz) {
            a[p] += v;
            p += p&-p;
        }
    }
    int sum(int p) {
        int ret = 0;
        while(p) {
            ret += a[p];
            p -= p&-p;
        }
        return ret;
    }
} bit;

struct Query{ int cmd, l, r, k, id; };

vector<int> ans(10005,1LL<<31);
vector<int> arr(50005);

void slv(int l, int r, vector<Query> &q) {
    if (l == r || q.empty()) {
        for (auto[cmd,ql,qr,k,id] : q) if(cmd) ans[id] = l;
        return;
    }
    int mid = (l+r)>>1;
    vector<Query> q1, q2;
    for (auto[cmd,ql,qr,k,id] : q) {
        if (cmd) {
            if (k <= bit.sum(qr)-bit.sum(ql-1)) q1.pb({cmd,ql,qr,k,id});
            else q2.pb({cmd,ql,qr,k-bit.sum(qr)+bit.sum(ql-1),id});
        } else {
            if (qr <= mid) {
                bit.add(ql,k);
                q1.pb({cmd,ql,qr,k,id});
            } else {
                q2.pb({cmd,ql,qr,k,id});
            }
        }
    }
    for (auto[cmd,ql,qr,k,id] : q1) if (!cmd) bit.add(ql,-k);
    slv(l,mid,q1), slv(mid+1,r,q2);
}

signed main() {
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t, n, qq; 
    cin>>t;
    vector<Query> q;
    while(t--) {
        cin>>n>>qq;
        q.clear();
        bit.init(n);
        
        for (int i = 1; i <= n; ++i) {
            cin>>arr[i];
            q.pb({0,i,arr[i],1,0});
        }
        int cmd, l, r, k;
        for (int i = 1; i <= qq; ++i) {
            cin>>cmd>>l>>r;
            if (cmd == 1) {
                cin>>k;
                q.pb({1,l,r,k,i});
            } else if (cmd == 2) {
                q.pb({0,l,arr[l],-1,0});
                q.pb({0,l,r,1,0});
                arr[l] = r;
            } else {
                ans[i] = 7122;
            }
        }
        slv(-(1LL<<31),(1LL<<31),q);
        for (auto& i : ans) {
            if (i < (1LL<<31)) {
                cout<<i<<endl;
                i = (1LL<<31);
            }
        }
    }
    return 0;
}

CDQ分治

一種分治

概念性算法

可以用於解決和點對有關的問題

例如偏序關係

一維偏序

就很顯然,排序完直接算

二維偏序

除了之前教過的類\(merge  sort\)的分治算法

(其實這也可以算是一種CDQ分治)

 

我們還可以對\(x\)排序

然後依序加入點的時候BIT維護\(y\)的前綴和

 

都是\(O(NlogN)\)

由大到小排序\(x\), 相同時由小到大排序\(y\)

對\(x\)分治

合併區間時改成對\(y\)由大到小排序

用BIT維護\(z\)的前綴和

 

當然沒人說不行套兩層CDQ分治

實做思路

針對\(x\),假設我們用\(solve(l,r)\)求解\([l,r]\)

且已經用遞迴解決完\([l,mid],[mid+1,r]\)

這時統計對每個在遞迴樹右邊的點

有多少在遞迴樹左邊的點滿足偏序關係

實做思路

對兩邊的點

以\(y\)(由大到小)合併排序

對\(z\)維護前綴和

\(O(Nlog^2N)\)

Code

#pragma GCC optimize("Ofast")
#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

const int maxn = 1e5+5;

int n;
vector<int> ans(maxn,0);

struct Point { 
    int x, y, z, id; 
    bool operator<(Point b) {
        if (x == b.x) return y < b.y;
        return x > b.x;
    }
};

struct BIT {
    vector<int> arr;
    int sz;
    void init(int _n) {
        sz = _n;
        arr.assign(sz+5,0);
    }
    void upd(int p, int v) {
        while(p <= sz) {
            arr[p] += v;
            p += p&-p;
        }
    }
    int sum(int p) {
        int ret = 0;
        while(p > 0) {
            ret += arr[p];
            p -= p&-p;
        }
        return ret;
    }
} bit;

void solve(int l, int r, vector<Point> &a) {
    if (l == r) return;
    int mid = (l+r)>>1;
    solve(l,mid,a), solve(mid+1,r,a);
    int lp = l, rp = mid+1;
    vector<Point> tmp;
    while(lp <= mid && rp <= r) {
        if (a[lp].y > a[rp].y) {
            bit.upd(a[lp].z,1);
            tmp.pb(a[lp++]);
        } else {
            ans[a[rp].id] += (bit.sum(maxn)-bit.sum(a[rp].z));
            tmp.pb(a[rp++]);
        }
    }
    while(lp <= mid) {
        bit.upd(a[lp].z,1);
        tmp.pb(a[lp++]);
    }
    while(rp <= r) {
        ans[a[rp].id] += (bit.sum(maxn)-bit.sum(a[rp].z));
        tmp.pb(a[rp++]);
    }
    for (int i = l; i <= mid; ++i) bit.upd(a[i].z,-1);
    for (int i = l; i <= r; ++i) a[i] = tmp[i-l];
}

signed main() {
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin>>n;
    vector<Point> a(n);
    bit.init(maxn);
    for (int i = 0; i < n; ++i) {
        cin>>a[i].x>>a[i].y>>a[i].z;
        a[i].id = i;
    }
    sort(a.begin(),a.end());
    solve(0,n-1,a);
    for (int i = 0; i < n; ++i) cout<<ans[i]<<endl;
    return 0;
}

好我們回到離線

剛剛那個就只是分治

那它跟離線有什麼關係呢?

 

先看個例題

如果我們把刪除改成加入呢?

問題相當於

每次加入一個數字

問現在有多少個逆序數對

偏序關係

設\(p\)是位置,\(v\)是值

 

先不管加入的問題,如果\((i,j)\)是逆序對

那一定符合下面的情況

\( p_i < p_j  \&\&  v_i > v_j \)

\(or\)

\( p_i > p_j  \&\&  v_i < v_j \)

考慮加入時間

設\(t\)是加入時間

逆序對\((i,j)\)同時要滿足\(t_i \leq t_j\)

 

\( p_i < p_j  \&\&  v_i > v_j \)

\( p_i > p_j  \&\&  v_i < v_j \)

顯然的三維偏序

 

1. \(t_i \leq t_j\)

2. \( p_i > p_j\)

3. \(v_i < v_j \)

1. \(t_i \leq t_j\)

2. \( p_i < p_j\)

3. \(v_i > v_j \)

Code

#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define endl '\n'
#define pb push_back
#define int long long

const int maxn = 1e5+1;
int n, m, x;
vector<int> ans(100005,0);

struct node{
    int p, v, t = 0;
    bool operator<(node b) {
        if (t == b.t) return p < b.p;
        return t < b.t;
    }
};

struct BIT {
    vector<int> arr;
    int sz;
    void init(int _n) {
        sz = _n;
        arr.assign(sz+5,0);
    }
    void upd(int p, int v) {
        while(p <= sz) {
            arr[p] += v;
            p += p&-p;
        }
    }
    int sum(int p) {
        int ret = 0;
        while(p > 0) {
            ret += arr[p];
            p -= p&-p;
        }
        return ret;
    }
} bit;

//ti >= tj, pi > pj, vi < vj
void solve1(int l, int r, vector<node> &a) {
    if (l == r) return;
    int mid = (l+r)>>1;
    solve1(l,mid,a), solve1(mid+1,r,a);
    int lp = l, rp = mid+1;
    vector<node> tmp;
    while(lp <= mid && rp <= r) {
        if (a[lp].p < a[rp].p) {
            bit.upd(a[lp].v,1);
            tmp.pb(a[lp++]);
        } else {
            ans[a[rp].t] += bit.sum(maxn)-bit.sum(a[rp].v);
            tmp.pb(a[rp++]);
        }
    }
    while(lp <= mid) {
        bit.upd(a[lp].v,1);
        tmp.pb(a[lp++]);
    }
    while(rp <= r) {
        ans[a[rp].t] += bit.sum(maxn)-bit.sum(a[rp].v);
        tmp.pb(a[rp++]);
    }
    for (int i = l; i <= mid; ++i) bit.upd(a[i].v,-1);
    for (int i = l; i <= r; ++i) a[i] = tmp[i-l];
}

//ti >= tj, pi < pj, vi > vj
void solve2(int l, int r, vector<node> &a) {
    if (l == r) return;
    int mid = (l+r)>>1;
    solve2(l,mid,a), solve2(mid+1,r,a);
    int lp = l, rp = mid+1;
    vector<node> tmp;
    while(lp <= mid && rp <= r) {
        if (a[lp].p > a[rp].p) {
            bit.upd(a[lp].v,1);
            tmp.pb(a[lp++]);
        } else {
            ans[a[rp].t] += bit.sum(a[rp].v-1);
            tmp.pb(a[rp++]);
        }
    }
    while(lp <= mid) {
        bit.upd(a[lp].v,1);
        tmp.pb(a[lp++]);
    }
    while(rp <= r) {
        ans[a[rp].t] += bit.sum(a[rp].v-1);
        tmp.pb(a[rp++]);
    }
    for (int i = l; i <= mid; ++i) bit.upd(a[i].v,-1);
    for (int i = l; i <= r; ++i) a[i] = tmp[i-l];
}

signed main() {
    scanf("%lld%lld",&n,&m);
    vector<node> a(n);
    vector<int> pos(n+1);
    bit.init(maxn);
    for (int i = 0; i < n; ++i) {
        scanf("%lld",&a[i].v);
        a[i].p = pos[a[i].v] = i;
    }
    for (int i = m; i > 0; --i) {
        scanf("%lld",&x);
        a[pos[x]].t = i;
    }
    sort(a.begin(),a.end());
    solve1(0,n-1,a);
    sort(a.begin(),a.end());
    solve2(0,n-1,a);
    for (int i = 1; i <= m; ++i) ans[i] += ans[i-1];
    for (int i = m; i > 0; --i) printf("%lld\n",ans[i]);
    return 0;
}

記得開long long:(

Tarjan's LCA

對,又是他

以\(DFS\)為主要算法結構

在\(DFS\)的過程中

紀錄訪問順序

輔以\(DSU\)去處理詢問

定義一些我們需要的東西

\(bnd[i]\):存所有跟節點\(i\)有關的詢問

\(prt\)陣列:每個節點的\(boss\),預設是自己

性質

\(DFS\)時,\(u,v\)的\(LCA\)一定比\(u,v\)更晚被\(pop\)掉

 換個角度,對於\(u,v\)兩點

在\(DFS\)時,一定是先從\(u\)離開到\(LCA\)

然後從\(LCA\)走到\(v\)

對\(v\)而言,\(LCA\)會是目前時間最近的非初次造訪點

所以我們可以做些什麼呢?

當\(DFS\)完子樹,離開一個節點\(v\)時

我們就把\(prt[v]\)設成\(v\)的父節點

這樣有什麼效果?

對於一組詢問\((u.v)\)

假設\(u\)已經被訪問過

這時候我如果訪問到\(v\)

那\(u\)的當前祖先正好會是\(LCA\)

畫圖解釋

實做

void Tarjan(int u,int f){//f:父節點

    for all queries about u://處理和u有關的詢問
          //如果相對的詢問點v有訪問過:
                LCA(u,v) = find_boss(v)
                //這邊套用DSU
   
    for all children of u:
          //DFS
    
    prt[u] = f;
}

Code

#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;

#define pii pair<int,int>
#define endl '\n'
#define pb push_back

map<pii,int> mp;
vector<int> dep, prt;

int fb(int x) {
    if (x == prt[x]) return x;
    return prt[x] = fb(prt[x]);
}

void Tarjan(int u,int f,int d,vector<vector<int> > &g,vector<set<int> > &bnd){
    dep[u] = d;
    for (auto v : bnd[u]) {
        if (dep[v]) {
            mp[{u,v}] = mp[{v,u}] = fb(v);
        }
    }
    for (auto v : g[u]) {
        if (v != f) {
            Tarjan(v,u,d+1,g,bnd);
        }
    }
    prt[u] = f;
}

signed main() {
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, Q; cin>>n>>Q;
    vector<vector<int> > g(n+1);
    for (int i = 1; i < n; ++i) {
        int a, b; cin>>a>>b;
        g[a].pb(b);
        g[b].pb(a);
    }
    vector<set<int> > bnd(n+1);
    dep.assign(n+1,0), prt.assign(n+1,0);
    for (int i = 1; i <= n; ++i) prt[i] = i;
    vector< pii > q(Q);
    for (int i = 0; i < Q; ++i) {
        int a, b; cin>>a>>b;
        q[i] = {a,b};
        bnd[a].insert(b);
        bnd[b].insert(a);
    }
    Tarjan(1,1,1,g,bnd);
    for (auto [a,b] : q) {
        int lca = mp[{a,b}];
        cout<<dep[a]+dep[b]-2*dep[lca]<<endl;
    }
    return 0;
}

其他有趣的離線題

植物大戰殭屍code

#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

const int maxn = 300005; 

vector<int> arr(10005,0);
vector<int> ans(1000005,0);

struct QUERY{
    int l, r, v, id;
    bool operator<(QUERY b) {
        return r < b.r;
    }
};

struct TRIE{
    vector<vector<int> > t;
    vector<int> nr;
    int cnt = 0;
    void init() {
        t.assign(maxn,vector<int>(2,0));
        nr.assign(maxn,0);
    }
    void upd(int p, int x, int d, int l) {
        nr[p] = l;
        int c = (x>>d)&1;
        if (!t[p][c]) t[p][c] = ++cnt;
        if (d >= 0) upd(t[p][c],x,d-1,l);
    }
    int query(int p, int x, int d, int l) {
        int c = ((x>>d)&1)^1;
        if (!t[p][c] || nr[t[p][c]] < l) c ^= 1;
        if (d == 0) return x^(c<<d);
        return (c<<d)^query(t[p][c],x,d-1,l);
    }
} trie;

signed main() {
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, Q; cin>>n>>Q;
    vector<QUERY> q(Q+1);
    for (int i = 1; i <= n; ++i) {
        cin>>arr[i];
        arr[i] ^= arr[i-1];
    }
    int l, r, v;
    for (int i = 1; i <= Q; ++i) {
        cin>>l>>r>>v;
        q[i] = {l,r,v,i};
    }
    sort(q.begin()+1,q.end());
    int p = 1;
    trie.init();
    for (int i = 0; i <= n; ++i) {
        while(p <= Q && q[p].r == i) {
            ans[q[p].id] = trie.query(0,q[p].v^arr[i],30,q[p].l);
            p++;
        }
        trie.upd(0,arr[i],30,i);
    }
    for (int i = 1; i <= Q; ++i) cout<<ans[i]<<endl;
    return 0;
}

Increasing Array Queries

#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 n, Q;

struct Query{
    int r, id;
};

struct SEG{
    vector<int> a, tg;
    void init(int _n) {
        a.assign(_n<<2,0);
        tg.assign(_n<<2,0);
    }
    void push(int p, int c) {
        if (tg[p]) {
            a[p] = tg[p]*(c+1);
            if (c) tg[p<<1] = tg[p];
            if (c) tg[p<<1|1] = tg[p];
            tg[p] = 0;
        }
    }
    void upd(int l, int r, int p, int ql, int qr, int v) {
        push(p,r-l);
        if (ql <= l && r <= qr) {
            tg[p] = v;
            return;
        }
        if (qr <= mid) upd(l,mid,p<<1,ql,qr,v);
        else if (ql > mid) upd(mid+1,r,p<<1|1,ql,qr,v);
        else {
            upd(l,mid,p<<1,ql,qr,v);
            upd(mid+1,r,p<<1|1,ql,qr,v);
        }
        a[p] = (tg[p<<1]?(tg[p<<1]*(mid-l+1)):a[p<<1]) + (tg[p<<1|1]?(tg[p<<1|1]*(r-mid)):a[p<<1|1]);
    }
    int sum(int l, int r, int p, int ql, int qr) {
        push(p,r-l);
        if (ql <= l && r <= qr) return a[p];
        if (qr <= mid) return sum(l,mid,p<<1,ql,qr);
        else if (ql > mid) return sum(mid+1,r,p<<1|1,ql,qr);
        else  return sum(l,mid,p<<1,ql,qr)+sum(mid+1,r,p<<1|1,ql,qr);
    }
} seg;

signed main() {
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin>>n>>Q;
    seg.init(n);
    vector<int> v(n+1,0);
    for (int i = 1; i <= n; ++i) {
        cin>>v[i];
        v[i] += v[i-1];
    }
    vector<vector<Query> > q(n+1);
    vector<int> ans(Q+1);
    for (int i = 1; i <= Q; ++i) {
        int l, r; cin>>l>>r;
        q[l].pb({r,i});
    }
    for (int i = n; i >= 1; --i) {
        int l = i, r = n+1;
        while(r-l > 1) {
            if (seg.sum(1,n,1,mid,mid) > v[i]-v[i-1]) r = mid;
            else l = mid;
        }
        seg.upd(1,n,1,i,l,v[i]-v[i-1]);
        for (auto [R,id] : q[i]) {
            ans[id] = seg.sum(1,n,1,i,R)-(v[R]-v[i-1]);
        }
    }
    for (int i = 1; i <= Q; ++i) {
        cout<<ans[i]<<endl;
    }
    return 0;
}

另一題有空補XD

離線

By Lai Hong An

離線

  • 258