CF1083C Max Mex 线段树

题面

CF1083C Max Mex

题解

首先我们考虑，如果一个数x是某条路径上的mex，那么这个数要满足什么条件？

• 1 ~ x - 1的数都必须出现过.
• x必须没出现过。

现在我们要最大化x，那么也就意味着我们要找到一条路径使得这个都出现过的前缀尽可能长。

第二个条件可以忽略,因为如果第1个条件满足，而第2个条件却不满足，意味着我们可以把x至少扩大1位，因为要求最大值，所以扩大肯定最优，因此我们肯定会扩大到不能扩大为止。

由此我们可以发现，x是满足可二分性的。

考虑在线段树上维护这个问题，区间\([l, r]\)表示值域区间为\([l, r]\)的点全都连接在一起形成的一条路径。

如果有这条路径，那么就存下左右端点，否则就不存。

那么考虑如何合并2个区间\([l, mid], [mid + 1, r]\)。

从4个端点中任取2个作为新的端点，如果另外2个端点均在这2个端点构成的路径上，那么我们就找到了一条新路径满足值域属于\([l, r]\)的点全在路径上。

这样做的正确性(最优性)依赖于权值两两不同，因此我们的选择是唯一的，因此肯定是最优选择。

有一个很简洁的式子可以用于判断一个点是否在某条路径上：

如果\(x\)在链\((u, v)\)上，设\(LCA(u, v) = y\)那么有：

\[((LCA(u, x) == x \oplus LCA(v, x) == x) \oplus LCA(x, y) == y)
\]

于是维护好之后剩下的事情就是在线段树上查询(二分)了。

#include<bits/stdc++.h>
using namespace std;
#define R register int
#define LL long long
#define AC 201000
#define ac 802000
#define h(x) ((x) << 1)

int n, m;
int Head[AC], date[AC], Next[AC], tot;
int v[AC], fa[AC], s[AC];//s[i]表示权值为i的是哪个，只需要在最开始用就可以了

inline int read()
{
    int x = 0;char c = getchar();
    while(c > '9' || c < '0') c = getchar();
    while(c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
    return x;
}

inline void add(int f, int w)
{date[++ tot] = w, Next[tot] = Head[f], Head[f] = tot;}

#define cal(x, y) ((dep[x] < dep[y]) ? x : y)//返回x, y中dep最小的那个
#define maxn 401000
int st[maxn][20], ss[maxn], dep[AC], t[maxn], p[maxn], first[AC], top;
struct ST_form{

    void dfs(int x)//求遍历的数组 + dep
    {
        ss[++ top] = x, first[x] = top;
        for(R i = Head[x]; i; i = Next[i])
        {
            int now = date[i];
            dep[now] = dep[x] + 1, dfs(now), ss[++ top] = x;//返回的时候也要加
        }
    }

    void build()
    {
        dep[1] = 1, dfs(1);
        int tmp = 1, cnt = 0;
        for(R i = 1; i <= top; i ++)
        {
            if(i == (tmp << 1)) tmp <<= 1, ++ cnt;
            p[i] = tmp, t[i] = cnt;
        }
        for(R i = 1; i <= top; i ++) st[i][0] = ss[i];
        tmp = 1;
        for(R i = 1; i <= 18; i ++)
        {
            for(R j = 1; j <= top; j ++)
                st[j][i] = cal(st[j][i - 1], st[min(j + tmp, top)][i - 1]);
            tmp <<= 1;
        }
    }

    inline int LCA(int x, int y)//st表求LCA
    {
        int l = first[x], r = first[y];
        if(l > r) swap(l, r);//不一定按顺序的
        int len = r - l + 1;
        return cal(st[l][t[len]], st[r - p[len] + 1][t[len]]);
    }
}T;

struct node{
    int lx, rx;
}tree[ac], go;

#define update(x) tree[x] = merge(tree[x << 1], tree[(x << 1) + 1]);
struct seg_tree{

    bool check(int x, int u, int v)//检查x是否在路径(u, v)上
    {
        int y = T.LCA(u, v);
        return ((T.LCA(u, x) == x || T.LCA(v, x) == x) && T.LCA(x, y) == y);
    }

    inline node merge(node ll, node rr)
    {
        if(!ll.lx || !rr.lx) return (node){0, 0};
        int s[5] = {ll.lx, ll.rx, rr.lx, rr.rx};
        for(R i = 0; i < 4; i ++)
            for(R j = i + 1; j < 4; j ++)
            {
                bool flag = true;
                if(s[i] == s[j]) continue;
                for(R k = 0; k < 4; k ++)
                    if(k != i && k != j && !check(s[k], s[i], s[j])) {flag = false; break;}
                if(flag) return (node){s[i], s[j]};
            }
        return (node){0, 0};
    }

    void build(int x, int l, int r)
    {
        if(l == r) {tree[x].lx = tree[x].rx = s[l]; return ;}
        int mid = (l + r) >> 1;
        build(h(x), l, mid), build(h(x) + 1, mid + 1, r);
        update(x);
    }

    void change(int x, int l, int r, int w)
    {
        if(l == r) {tree[x].lx = tree[x].rx = w; return ;}
        int mid = (l + r) >> 1;
        if(v[w] <= mid) change(h(x), l, mid, w);
        else change(h(x) + 1, mid + 1, r, w);
        update(x);
    }

    int find(int x, int l, int r)
    {
        int mid = (l + r) >> 1;
        if(l == r)
        {
            node tmp = go.lx ? merge(go, tree[x]) : tree[x];
            if(tmp.lx) {go = tmp; return 1;}
            return 0;
        }
        if(!tree[h(x)].lx) return find(h(x), l, mid);
        else
        {
            node tmp = go.lx ? merge(go, tree[h(x)]) : tree[h(x)];
            if(!tmp.lx) return find(h(x), l, mid);
            else {go = tmp; return mid - l + 1 + find(h(x) + 1, mid + 1, r);}
        }
    }

}T1;

void pre()
{
    n = read();
    for(R i = 1; i <= n; i ++) v[i] = read() + 1, s[v[i]] = i;
    for(R i = 2; i <= n; i ++) fa[i] = read(), add(fa[i], i);
}

void work()
{
    m = read();
    for(R i = 1; i <= m; i ++)
    {
        int opt = read();
        if(opt == 1)
        {
            int x = read(), y = read();
            swap(v[x], v[y]);
            T1.change(1, 1, n, x), T1.change(1, 1, n, y);
        }
        else go.lx = go.rx = 0, printf("%d\n", T1.find(1, 1, n));//因为向右平移了1，所以要移回来,+ 1 - 1就恰好抵消了
    }
}

int main()
{
//	freopen("in.in", "r", stdin);
    pre();
    T.build();
    T1.build(1, 1, n);
    work();
//	fclose(stdin);
    return 0;
}