[WC2018]即时战略——动态点分治(替罪羊式点分树)

题目链接：

[WC2018]即时战略

题目大意：给一棵结构未知的树，初始时除1号点其他点都是黑色，1号点是白色，每次你可以询问一条起点为白色终点任意的路径，交互库会自动返回给你这条路径上与起点相邻的节点并且如果这个点为黑色则将它变为白色，要求在不多于给定次数的询问内使所有点变为白色。

大致思路为按一定顺序分别将n-1个点变为白点，为了防止被卡，需要对2~n的序列随机打乱再按打乱后的顺序逐个变白。

数据范围分为三种，分开讲解(假设当前要变白的点为x)：

一、完全二叉树

这一部分比较简单，我们只需要按照一定顺序将每个点都变为白点即可。对于将每个点x变为白色的过程，因为可以确定上次询问的点一定是白点，所以我们每次询问以上次询问所返回的点为起点(第一次以根节点即1号点为起点)，以x为终点询问，直到返回点为x为止。因为树高严格logn，询问次数为nlogn。

二、链

可以发现被变白的点一定是连续的一段，我们记录这一段的左右端点，每次先询问从一个端点到x的路径，如果返回点为白点说明x在1号点的另一边，再一直询问从另一个端点到x的路径并更新端点，直到x被变白为止。这样期望询问次数为n+logn(最大为2n)，为了防止被卡，建议每次首先询问的端点左右交替，不要一直先询问左端点或右端点。

三、无限制

这一部分是本题的重点，题目要求的询问数上限为nlogn。可以发现白点一定组成一个联通块，对于每个待寻找的点，只要找到当前所有白点中与它相连的点即可。从完全二叉树的做法中我们可以得到启发：如果在寻找每个点的过程中只遍历到logn个节点，那么就能满足要求。而原树树高上限是O(n)，无法在原树上直接寻找，但点分树保证树高为logn啊！我们每一次从点分树的根开始，假设当前走到的点为now，那么每次询问从now到x的路径，假设返回点为y，y一定是以now为分治中心时，now的一个子节点，而x一定是在y这个子树所表示的联通块中，我们只要下一次将now变为y这棵子树的分治中心再寻找就能使查找范围减小至少一半。因为时间复杂度上限不在查询上，所以对于每一次查找y这棵子树的分治中心可以直接在点分树上从y暴力往上爬，直到爬到点的父节点是now为止，这样可以减少存储的信息量(方便后边的重构)。如果对于一次询问返回点为黑点，那么需要将这个点插入到点分树中，我们直接将这个点连到当前now的下面即可。这样建出的点分树会很不平衡，我们像紫荆花之恋那道题一样设置一个平衡因子，每次插入后找到离根最近的不平衡点，对这个点在点分树上的子树进行点分治然后建出这棵子树真正的点分树，注意重构点可能是点分树的根，所以要记录点分树的根是谁。每次重构均摊O(logn^2)，总时间复杂度为O(nlogn^2)，询问次数为nlogn。

#include"rts.h"
#include<map>
#include<cmath>
#include<vector>
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
int tot;
int vis[300010];
int head[300010];
int to[600010];
int next[600010];
int f[300010];
int size[300010];
int mx[300010];
int root;
int num;
int id[300010];
int col[300010];
int l,r;
int now;
int point;
int rot;
vector<int>q[300010];
inline void add(int x,int y)
{
    next[++tot]=head[x];
    head[x]=tot;
    to[tot]=y;
}
void getroot(int x,int fa)
{
    size[x]=1;
    mx[x]=0;
    for(int i=head[x];i;i=next[i])
    {
        if(!vis[to[i]]&&to[i]!=fa)
        {
            getroot(to[i],x);
            size[x]+=size[to[i]];
            mx[x]=max(mx[x],size[to[i]]);
        }
    }
    mx[x]=max(num-size[x],mx[x]);
    if(mx[x]<mx[root])
    {
        root=x;
    }
}
void dfs(int x,int fa,int rt)
{
    q[rt].push_back(x);
    size[x]=1;
    for(int i=head[x];i;i=next[i])
    {
        if(!vis[to[i]]&&to[i]!=fa)
        {
            dfs(to[i],x,rt);
            size[x]+=size[to[i]];
        }
    }
}
void partation(int x,int fa)
{
    vis[x]=1;
    f[x]=fa;
    q[x].clear();
    dfs(x,0,x);
    for(int i=head[x];i;i=next[i])
    {
        if(!vis[to[i]])
        {
            num=size[to[i]];
            root=0;
            getroot(to[i],0);
            partation(root,x);
        }
    }
}
inline void insert(int x,int fa)
{
    point=-1;
    f[x]=fa;
    vis[x]=1;
    for(int i=x;i;i=f[i])
    {
        q[i].push_back(x);
        size[i]++;
        if(f[i]&&size[i]*100>(size[f[i]]+1)*90)
        {
            point=f[i];
        }
    }
    if(point!=-1)
    {
        int len=q[point].size();
        for(int i=0;i<len;i++)
        {
            vis[q[point][i]]=0;
        }
        num=size[point];
        root=0;
        getroot(point,0);
        if(point==rot)
        {
            rot=root;
        }
        partation(root,f[point]);
    }
}
void play(int n,int T,int type)
{
    for(int i=2;i<=n;i++)
    {
        id[i]=i;
    }
    srand(12345678);
    random_shuffle(id+2,id+n+1);
    col[1]=1;
    size[1]=1;
    vis[1]=1;
    q[1].push_back(1);
    mx[0]=1<<30;
    if(type==3)
    {

        random_shuffle(id+2,id+n+1);
        l=r=1;
        for(int i=2;i<=n;i++)
        {
            if(col[id[i]])
            {
                continue;
            }
            if(col[explore(l,id[i])])
            {
                while(!col[id[i]])
                {
                    col[now=explore(r,id[i])]=1;
                    r=now;
                }
            }
            else
            {
                while(!col[id[i]])
                {
                    col[now=explore(l,id[i])]=1;
                    l=now;
                }
            }
            swap(l,r);
        }
        return ;
    }
    else
    {
        rot=1;
        for(int i=2;i<=n;i++)
        {
            now=rot;
            while(!col[id[i]])
            {
                int num=explore(now,id[i]);
                if(col[num])
                {
                    while(f[num]!=now)
                    {
                        num=f[num];
                    }
                    now=num;
                }
                else
                {
                    add(now,num);
                    add(num,now);
                    col[num]=1;
                    insert(num,now);
                    now=num;
                }
            }
        }
        return ;
    }
}