HDU 6756 暴力开点BIT+二分+启发式

此部分为转载：

每次更新一个点x，其周围点y。每次只把更新x造成的影响，在deg[y]>deg[x]的点y中更新。

而每次查询一个点x时，其周围点y。对于deg[y]<deg[x]的点y更新对x造成的影响已经被更新过了。

所以只需要考虑所有deg[y]>=deg[x]的点y的更新对x造成的影响即可。

这样每次更新与查询都是根号n。

然后对于维护mex，我们用BIT来处理：

对每个点x，开一个大小为deg[x]的树状数组。BIT中C数组维护点x周围是否含有i的值。

那么我们二分BIT，找到最右边使得sum[mid]==mid的值，mid+1就是最小未出现的整数。

然后再开一个nm数组维护每个点周围的个数，辅助BIT。

每次更新时，更新其周围度数大于其的点。

查询时，把其周围度数大于其的点更新的影响加入，然后查询结果。最后消除影响即可。
 

//#define LOCAL
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mem(a, b) memset(a,b,sizeof(a))
#define INF 0x3f3f3f3f
#define DNF 0x7f
#define DBG printf("this is a input\n")
#define fi first
#define se second
#define mk(a, b) make_pair(a,b)
#define pb push_back
#define LF putchar('\n')
#define SP putchar(' ')
#define p_queue priority_queue
#define CLOSE ios::sync_with_stdio(0); cin.tie(0)

template<typename T>
void read(T &x) {x = 0;char ch = getchar();ll f = 1;while(!isdigit(ch)){if(ch == '-')f *= -1;ch = getchar();}while(isdigit(ch)){x = x * 10 + ch - 48; ch = getchar();}x *= f;}
template<typename T, typename... Args>
void read(T &first, Args& ... args) {read(first);read(args...);}
template<typename T>
void write(T arg) {T x = arg;if(x < 0) {putchar('-'); x =- x;}if(x > 9) {write(x / 10);}putchar(x % 10 + '0');}
template<typename T, typename ... Ts>
void write(T arg, Ts ... args) {write(arg);if(sizeof...(args) != 0) {putchar(' ');write(args ...);}}
using namespace std;

ll gcd(ll a, ll b) {
    return b == 0 ? a : gcd(b, a % b);
}

ll lcm(ll a, ll b) {
    return a / gcd(a, b) * b;
}
int n, m;
const int N = 2e5 + 5;
vector <int> edge[N];
vector <int> big[N], biger[N];
vector <int> tree[N], mark[N];
int siz[N], val[N], degree[N];
int lowbit(int x)
{
    return x & (-x);
}
int sum (int k,int x)
{
    int ret=0;
    while (x)
    {
        ret += tree[k][x];
        x -= lowbit(x);
    }
    return ret;
}
int qu (int k , int x , int y)
{
    return sum(k,y) - sum(k,x-1);
}
void up (int k ,int x ,int d)
{
    while(x <= siz[k])
    {
        tree[k][x] += d;
        x += lowbit(x);
    }
}

int main()
{
    int T;
    read(T);
    while (T --)
    {
        read(n, m);
        for (int i = 1; i <= n ; i ++)
            degree[i] = 0 , edge[i].clear(), tree[i].clear() , biger[i].clear() , big[i].clear(), mark[i].clear();
        for (int i = 1; i <= n ; i ++)
        {
            read(val[i]);
            val[i] ++;
        }
        for (int i = 1 ; i <= m ; i ++)
        {
            int u , v;
            read(u,v);
            edge[u].pb(v);
            edge[v].pb(u);
            degree[u] ++, degree[v] ++;
        }
        for (int u = 1 ; u <= n ; u ++)
        {
            for (auto v : edge[u])
            {
                if(degree[v] > degree[u]) big[u].pb(v);
                if(degree[v] >= degree[u]) biger[u].pb(v);
            }
            siz[u] = edge[u].size();
            tree[u].resize((siz[u]+1)*4,0);
            mark[u].resize(siz[u]+1,0);
        }
        for (int u = 1 ; u <= n ; u ++)
        {
            for (auto v : big[u])
            {
                if(val[u] > siz[v]) continue;
                mark[v][val[u]] ++;
                if(mark[v][val[u]] == 1)
                    up(v,val[u],1);
            }
        }
        int q;
        read(q);
        while(q --)
        {
            int op , x , y;
            read(op);
            if(op == 1)
            {
                read(x,y);
                y += 1;
                int last = val[x];
                val[x] = y;
                if(val[x] == last)
                    continue;
                for (auto v : big[x])
                {
                    if (last <= siz[v])
                    {
                        mark[v][last] --;
                        if (mark[v][last] == 0)
                            up (v, last , -1);
                    }
                    if (y <= siz[v])
                    {
                        mark[v][y] ++;
                        if (mark[v][y] == 1)
                            up(v, y, 1);
                    }
                }
            }
            else
            {
                read(x);
                for (auto v : biger[x])
                {
                    if(val[v] <= siz[x])
                    {
                        mark[x][val[v]] ++;
                        if (mark[x][val[v]] == 1)
                            up(x, val[v], 1);
                    }

                }
                int l = 1 , r = siz[x]+1;
                while(l < r)
                {
                    int mid = (l + r) / 2;
                    if(qu(x,1,mid) == mid)
                        l = mid + 1;
                    else
                        r = mid;
                }
                write(r-1), LF;
                for (auto v : biger[x])
                {
                    if(val[v] <= siz[x])
                    {
                        mark[x][val[v]] --;
                        if (mark[x][val[v]] == 0)
                            up(x, val[v], -1);
                    }
                }
            }
        }
    }
}
/*
5
2 3 6 7 8
 */