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

cpp 复制代码

#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;
}

「模拟赛」CSP-S 模拟 11（T2 超详细）

A.玩水 (water)

B. AVL 树