浅谈区间MEX问题

区间MEX问题

MEX是什么

MEX：指一个序列中最小没有出现过的自然数。

例如 $m e x {1, 2, 0, 3} = 4$ , $m e x {5, 1, 2, 3} = 0$ ， $m e x {0, 2, 1, 5} = 3$

在谈到区间MEX之前，我们先实现一个维护MEX的数据结构。

这个数据结构需要支持这样的操作：

对集合进行插入或删除
查询集合的MEX

我们可以开一个 $v i s$ 数组，表示某个数是否出现过。那么往集合中插入一个数的时候，就把 $v i s_{i}$ 标记为 1 ，删除就标记为 0 。查询的时候，就从0开始暴力枚举，第一个 $v i s_{i} = 0$ 的就是 MEX。显然，这样时间复杂度是非常高的，我们考虑优化一下这个暴力枚举的过程。我们可以维护一个 $s e t$ ，表示未出现的数的集合，当我们添加一个新的数的时候，就在 $s e t$ 中将其删去，如果删除操作使得一个数没有出现过，就把他加入 $s e t$ 。那么查询 MEX 的时候直接查询 $s e t$ 中的最小值即可。

int cnt[N];
set<int> st;
int m, op, x;

void solve()
{
    for(int i = 0; i < N; i ++)
        st.insert(i);
    cin >> m;
    while(m --)
    {
        cin >> op;
        if(op == 0) //add
        {
            cin >> x;
           	if(cnt[x] == 0)
                st.erase(x);
            cnt[x] ++;
        }
        else if(op == 1) //query
        {
            cout << *st.begin() << '\n';
        }
        else //delete
        {
            cin >> x;
            if(-- cnt[x] == 0)
                st.insert(x);
	}
    }
}

复杂度为 $O (n l o g n)$

注：在长度为 n 的集合中，MEX的最大值为 n，所以可以把大于 n 的都改为 $n + 1$ 。

区间MEX

在了解MEX的概念之后，我们引入一道题目来说明一下什么是区间MEX

Rmq Problem / mex

区间MEX，就是查询一个序列中指定区间的MEX，序列不带修。

方法1：离线 + 线段树

这是一个区间问题，对于区间问题我们常常可以考虑是否能够通过离线来处理问题。线段树维护的是一个叫 $l a s t_p o s$ 的东西，表示某个数最后一次在数组中出现的位置，维护他的区间最小值。我们先对询问区间按右端点排序，遍历一遍 1 到 n ，把 $a_{i}$ 更新到线段树中的同时，若 $i = q u e r y [j] . R$ ，这个时候就可以对 $q u e r y [j]$ 的答案进行计算了。怎么计算呢？我们直接找到最后一次位置小于 $q u e r y [j] . l$ 的最小的数。那我们直接在线段树上二分就可以了。

#include <bits/stdc++.h>

using namespace std;
const int N = 300005;
struct ASK {
	int l, r, id, mex;
};
int n, m;
int a[N];
ASK Q[N];

struct Seg_tree1  {
    struct Tree {
    	int l, r;
    	int v;
    } seg[N << 2];
    void pushup(int k)
    {
        seg[k].v = min(seg[k << 1].v, seg[k << 1 | 1].v);
    }
    void build(int k, int l, int r)
    {
        seg[k] = {l, r, 0};
        if(l == r) {
            return;
        }   
        int mid = (l + r) >> 1;
        build(k << 1, l, mid);
        build(k << 1 | 1, mid + 1, r);
    }
    void modify(int k, int pos, int x)
    {
        int l = seg[k].l, r = seg[k].r;
        if(l == r) {
            seg[k].v = x;
            return;
        }
        int mid = (l + r) >> 1;
        if(pos <= mid)
            modify(k << 1, pos, x);
        else
            modify(k << 1 | 1, pos, x);
        pushup(k);
    }
    int query(int k, int pos)
    {
        int l = seg[k].l, r = seg[k].r;
        if(l == r) {
            return seg[k].l;
        }
        if(seg[k << 1].v < pos)
            return query(k << 1, pos);
        else
            return query(k << 1 | 1, pos);
    }
};

Seg_tree1 T1;

int main()
{
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i ++)
    {
    	scanf("%d", &a[i]), a[i] ++;
        a[i] = min(a[i], n + 2);
    }
    T1.build(1, 1, n + 2);

    for(int i = 1; i <= m; i ++)
    {
    	int l, r;
    	scanf("%d%d", &l, &r);
    	Q[i] = {l, r, i, 0};
    }

    sort(Q + 1, Q + m + 1, [](ASK a, ASK b) {return a.r < b.r;});

    for(int i = 1, j = 1; i <= n; i ++)
    {
    	T1.modify(1, a[i], i);
    	while(j <= m && Q[j].r == i)
    	{
    	    Q[j].mex = T1.query(1, Q[j].l);
       	    j ++;
    	}
    }

    sort(Q + 1, Q + m + 1, [](ASK a, ASK b) {return a.id < b.id;});
    for(int i = 1; i <= m; i ++)
    	printf("%d\n", Q[i].mex - 1);
}

方法2：在线 + 主席树

如果学习过主席树的话，不难想到，跟上面离线的思想是一模一样的，对于一个询问 $[L, R]$ ，我们可以直接在 $r o o t [R]$ 上进行查询第一个最后一次出现的位置小于 $L$ 的权值即可。

#include <bits/stdc++.h>

using namespace std;
const int N = 200005;

int tot = 0;
struct node {
    int ls, rs;
    int v;
} seg[N * 24];
int rt[N], a[N];
int n, m;

void pushup(int k)
{
    seg[k].v = min(seg[seg[k].ls].v, seg[seg[k].rs].v);
}
int modify(int old, int l, int r, int pos, int v)
{
    int p = ++tot;
    seg[p] = seg[old];
    if (l == r)
    {
        seg[p].v = v;
        return p;
    }
    int mid = (l + r) >> 1;
    if (pos <= mid)
        seg[p].ls = modify(seg[old].ls, l, mid, pos, v);
    else
        seg[p].rs = modify(seg[old].rs, mid + 1, r, pos, v);
    pushup(p);
    return p;
}
int query(int p, int l, int r, int pos)
{
    if (l == r)
    {
        return l;
    }
    int mid = (l + r) >> 1;
    if (seg[seg[p].ls].v < pos)
        return query(seg[p].ls, l, mid, pos);
    else
        return query(seg[p].rs, mid + 1, r, pos);
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
        rt[i] = modify(rt[i - 1], 0, n, a[i], i);
    }
    while (m--)
    {
        int l, r;
        cin >> l >> r;
        cout << query(rt[r], 0, n, l) << '\n';
    }
}