「模擬賽」CSP-S 模擬 11（T2 超詳細）

Aqr_Rn發表於2024-10-14

比賽連結

A.玩水 (water)

簽到。發現如果要找兩條路徑的話，能找到的充要條件是存在一個點的上方和左方的字母相同。（即使兩條走過的點截然不同的路徑也符合，這時終點會成為這個點）。

即存在一個位置 \((i,j)\) 使得 \(s_{i-1,j}=s_{i,j-1}\)，我們稱位置 \((i,j)\) 是好位置。

擴充套件到三條路發現，存在上面的兩個好位置就可以了，但對這兩個位置有要求：

  • 兩點相鄰，即以下情形：

或者 同一列上相鄰

  • 兩個好位置 \((i_1,j_1),(i_2,j_2)\) 滿足 \(i_2>i_1,j_2>j_1\)

B. AVL 樹

貪心，思路其實很簡單，只不過不好實現。

發現儘量留下小的節點比較優，於是中序遍歷，每到一個節點則求出若留下它則至少要留多少個點（設這個數量為 \(x\)），比較 \(x\) 與 \(k\)，若 \(x<k\) 則這個點可以留下來，標記上。

考慮具體如何查詢一個點若留下，整棵樹至少要留下的點的個數。

  • 對於查詢：

    某個點若留下來，在該點不斷跳父親的過程中，其另一邊子樹為了滿足 AVL 樹的平衡性質而要取到與該側子樹最大深度相差小於等於 1 的深度。這一要求對需要留下點的個數造成貢獻。

    發現若一顆 AVL 樹的高度若是確定的，則它最少包含的節點數量可求：

    可以預處理出來 \(f[i]\)，表示深度為 i 的AVL樹，節點數至少多大。有遞推式 \(f[i]=f[i−1]+f[i−2]+1\)，可以看作一邊深度為 i−1，一邊深度為 i−2，在上面接上了根節點。

    那麼查詢求出一個點留下來，一直回溯它的祖先節點直到根，對於該節點是左兒子的情況計算出保留這個節點至少需要右子樹中有多少個節點，即可轉化成求右子樹的最小高度。

    我們維護每個點的 深度 \(dep\)、子樹內最大深度 \(dmax\)，dfs 預處理這兩個資訊即可。

    還要維護每個點為根的 子樹中已選點的最大深度 \(had\)，和若留下該點至少需要的深度 \(ned\)。

    這樣詢問所需點的個數就好說了，在詢問點不斷跳父親回溯的過程中，當跳到的點是左兒子時，求出保留這個點，它父節點的右兒子需要達到的最小高度。（因為當前左子樹有一定深度，為了滿足 AVL 樹的性質，要使右子樹的深度與其差值小於等於 1）

具體看程式碼，那麼現在我們還需要實時更新這些資訊。

  • 考慮更新：

    • 每個點被選後都要不斷回溯祖先節點至根節點來更新它所有祖先節點的已選子樹的最大深度；

    • 並且回溯過程中，該點為左兒子時需要更新父節點的右兒子留下來需要的最大深度，（為了保證滿足 AVL 樹的要求，即兩兒子子樹的高度差值不超過 1）

      而該點為右兒子時則不用管父節點的左兒子，因為左兒子一定被我們優先考慮過是否可留下，右兒子在左兒子之後遍歷到，不對左兒子有影響。

由於 AVL 樹的性質，高度約為 \(\log n\)，所以整體複雜度為 \(O(n\log n)\)。

具體還有很詳細的程式碼註釋：

code 
#include<bits/stdc++.h>
#define mp make_pair
#define Type int
#define qr(x) x=read()
typedef __int128 INT;
typedef long long ll;
using namespace std;

inline Type read(){
    char c=getchar(); Type x=0, f=1;
    while(!isdigit(c)) (c=='-'?f=-1:f=1), c=getchar();
    while(isdigit(c)) x=(x<<1)+(x<<3)+(c^48), c=getchar();
    return x*f;
}

const int N = 5e5 + 5; 

int n, k, root, whi[N];
int son[N][2], fa[N], f[N];

int dep[N], dmax[N];
inline void dfs(int x, int p){ dfs 預處理
    dmax[x] = dep[x] = dep[p] + 1;
    for(int i=0; i<2; i++){
        int y = son[x][i];
        if(!y) continue;
        dfs(y, x);
        dmax[x] = max(dmax[x], dmax[y]);
    }
}

int ned[N], had[N], vis[N];
inline int query(int u){
    int y = u, x = fa[u], res = 0;
    while(x != -1){
        if(!whi[y]) res += f[max({had[x]-1, dep[u]-1, ned[son[x][1]]})-dep[x]];// 跳到點為左兒子時，加上右兒子的貢獻
        y = x, x = fa[x];
    }
    return res;
}

inline void update(int u){ //選了一個點，更新它對祖先節點的影響
    had[u] = max(had[u], dep[u]); 
    int y = u, x = fa[u];
    while(x != -1){
        had[x] = max(had[x], dep[u]);//更新子樹內已選的點的最大深度
        if(!whi[y] and son[x][1]) ned[son[x][1]] = max(ned[son[x][1]], had[x] - 1); //該點是左兒子，更新若選右兒子需要的最大深度
        y = x, x = fa[x];
    }
}

inline void DFS(int x){
    if(query(x) < k){
        vis[x] = true;
        k--; update(x);
    }
    if(son[x][0] and dmax[son[x][0]] >= ned[x]){ //左子樹的最大深度達得到父節點需要的就選擇左子樹
        ned[son[x][0]] = max(ned[son[x][0]], ned[x]);
        if(son[x][1]) ned[son[x][1]] = max(ned[son[x][1]], ned[x] - 1);
    }
    else if(son[x][1]){ //否則選擇右子樹
        ned[son[x][1]] = max(ned[son[x][1]], ned[x]);
        if(son[x][0]) ned[son[x][0]] = max(ned[son[x][0]], ned[x] - 1);
    }

    for(int i=0; i<2; i++){
        int y = son[x][i];
        if(!y) continue;
        DFS(y);
    }
}

signed main(){ //avl
    freopen("avl.in", "r", stdin), freopen("avl.out", "w", stdout);

    qr(n), qr(k);
    for(int i=1; i<=n; i++){
        qr(fa[i]);
        if(fa[i] == -1){root = i;continue;}
        whi[i] = (i < fa[i] ? 0 : 1); //判斷該點是其父節點的左子樹還是右子樹
        son[fa[i]][whi[i]] = i;
    }

    if(k == 1){
        for(int i=1; i<=n; i++)
            cout<<(i == root ? 1 : 0);
        return 0;
    }

    dfs(root, 0);

    f[1] = 1;
    for(int i=2; i<=30; i++) f[i] = f[i-1] + f[i-2] + 1; //遞推求深度為 i 的 AVL 樹的最少節點數

    DFS(root);        

    for(int i=1; i<=n; i++)
        cout<<vis[i];
    cout<<'\n';


    return 0;
}

相關文章