动态点分治

最新推荐文章于 2021-05-17 22:52:59 发布

Wuliwuliii

最新推荐文章于 2021-05-17 22:52:59 发布

阅读量615

点赞数 2

分类专栏：动态点分治欧拉序点分治文章标签：动态点分治欧拉序与LCA

本文链接：https://blog.csdn.net/qq_41730082/article/details/105469969

版权

点分治同时被 3 个专栏收录

17 篇文章 0 订阅

订阅专栏

欧拉序

11 篇文章 0 订阅

订阅专栏

动态点分治

8 篇文章 0 订阅

订阅专栏

点分治，作为树分治中的一种，在很多树形结构的问题上起到了很重要的作用，但是假如我们在树分治的基础上，根据时间戳来对树上的结点进行修改的话，那样岂不是很难受？

点分治该怎么搞？暴力，当然是暴力啊？每次修改一次，我们暴力点分一次，复杂度升天 $O(Q*N*log(N))$ 。

那么，就该介绍一下动态点分治了！

动态点分治

动态点分治，我们知道每个点分树的父节点是固定的，此话怎讲？我们模拟一下点分治的过程，首先，找到一个根结点root，然后从它开始进行一系列计值算法，接下去是分治，我们对于root的v结点方向，找到一个新的根rt，那么，我们认为root是rt的父结点。

所以，每个结点的父节点是固定的，而且可以通过父节点来储存目前点分树的一些信息。

在这里，我们给出一个很重要的前提，树的结构是不随时间而改变的（树结构固定）。不然，若是树的结构有变化，那么就需要利用LCT来解决了。

确定每个结点的父结点，然后，我们假如要对一个点进行修改的话，实际上可以看成我们修改从这个点一直向上跳fa[x]直到跳完。因为它只从属于这些子树，所以只需要最多跳 $O(log(N))$ 次。

对每一个结点，可能需要维护一个堆，或者是数据结构，所以可能存在一些其他复杂度。譬如就拿一道例题来说明吧。

Hide 捉迷藏 BZOJ - 1095

多次修改，查询最远两个关灯结点的距离。

因为，修改操作只是对一个点x，将x点翻转，开关反转。

所以，每次最多只是对一个点，和它的所有祖先结点进行操作，对于树形结构的直径是怎样求解的呢？

$ans = max(ans, dp[u][0] + dp[u][1])$

经过u点的最远的点，和不再这条路径上的次元的点的距离和，对于所有的u点都搜一遍，就能确定答案了。

所以，我们可以用一个堆来维护每个以点x为根的子树的所有的点到x的父结点的距离。堆按照降序排列，然后，我们在来一个堆，维护每个以点x为父结点的结点的第一个堆的堆顶，是因为从每个路径上只能来一个最大距离。

那么，在答案处理上，我们仍然要存储所有的信息，有的结点可能在经过一次处理之后变成了直径，但是它并不在修改结点到祖先的路径上，我们需要避免这种情况。

然后关键的，我们要给第二个堆，最早的时候push(0)，这是考虑到，从该结点出发，与到它的最远路径形成了一个直径的情况，也就是 $ans = max(ans, dp[u][0])$ 这层意思，因为有可能此时dp[u][1]不存在。

关于堆的维护

$top()$

$pop()$

$size()$

$push()$

这些都是堆的基本操作，这里还需要加一个堆顶+次堆顶之和。

造了一些数据

4
1 2
1 3
3 4
2
C 2
G
ans:2

4
1 2
1 3
3 4
4
C 4
C 2
C 2
G
ans:2

代码

做好充分的心里准备，第一次写，应该会debug很久的，我造了那么多样例，也是为了说明这个hh。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
//#include <unordered_map>
//#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define eps 1e-6
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 1e5 + 7;
int N, Q, head[maxN], cnt, LOG_2[maxN << 1];
struct Eddge
{
    int nex, to;
    Eddge(int a=-1, int b=0):nex(a), to(b) {}
} edge[maxN << 1];
inline void addEddge(int u, int v)
{
    edge[cnt] = Eddge(head[u], v);
    head[u] = cnt++;
};
inline void _add(int u, int v) { addEddge(u, v); addEddge(v, u); }
struct Grand_Father
{
    int deep[maxN], euler[maxN << 1], Esiz, rid[maxN];
    void dfs(int u, int fa)
    {
        deep[u] = deep[fa] + 1; rid[u] = Esiz + 1;
        for(int i=head[u], v; ~i; i=edge[i].nex)
        {
            v = edge[i].to;
            if(v == fa) continue;
            euler[++Esiz] = u;
            dfs(v, u);
        }
        euler[++Esiz] = u;
    }
    int mn[maxN << 1][20];
    inline void RMQ_Init()
    {
        for(int i=1; i<=Esiz; i++) mn[i][0] = euler[i];
        for(int j=1; (1 << j) <= Esiz; j++)
        {
            for(int i=1; i + (1 << j) - 1 <= Esiz; i++)
            {
                if(deep[mn[i][j - 1]] < deep[mn[i + (1 << (j - 1))][j - 1]]) mn[i][j] = mn[i][j - 1];
                else mn[i][j] = mn[i + (1 << (j - 1))][j - 1];
            }
        }
    }
    inline int Rmq(int l, int r)
    {
        int det = r - l + 1, kk = LOG_2[det];
        if(deep[mn[l][kk]] <= deep[mn[r - (1 << kk) + 1][kk]]) return mn[l][kk];
        else return mn[r - (1 << kk) + 1][kk];
    }
    inline int _LCA(int u, int v)
    {
        int l = rid[u], r = rid[v];
        if(l > r) swap(l, r);
        return Rmq(l, r);
    }
    inline int _Dis(int u, int v)
    {
        int lca = _LCA(u, v);
        return deep[u] + deep[v] - 2 * deep[lca];
    }
} A_lca;
struct heap
{
    priority_queue<int> Que, Del;
    inline int top()
    {
        while(!Que.empty() && !Del.empty() && Que.top() == Del.top()) { Que.pop(); Del.pop(); }
        return Que.top();
    }
    void clear(int val) { Del.push(val); }
    inline bool empty()
    {
        while(!Que.empty() && !Del.empty() && Que.top() == Del.top()) { Que.pop(); Del.pop(); }
        return Que.empty();
    }
    inline void pop()
    {
        while(!Que.empty() && !Del.empty() && Que.top() == Del.top()) { Que.pop(); Del.pop(); }
        if(!Que.empty()) Que.pop();
    }
    inline void push(int val) { Que.push(val); }
    inline int Fir_Sec()
    {
        int tmp[2]; tmp[0] = tmp[1] = 0;
        if(!empty())
        {
            tmp[0] = top();
            pop();
            if(!empty())
            {
                tmp[1] = top();
                
            }
            Que.push(tmp[0]);
        }
        return tmp[0] + tmp[1];
    }
    inline int size() { return (int)(Que.size() - Del.size()); }
} ans, p[maxN][2];
int root, all, son[maxN], siz[maxN], maxx, father[maxN];
bool vis[maxN];
void findroot(int u, int fa)
{
    siz[u] = 1; son[u] = 0;
    for(int i=head[u], v; ~i; i=edge[i].nex)
    {
        v = edge[i].to;
        if(vis[v] || v == fa) continue;
        findroot(v, u);
        siz[u] += siz[v];
        son[u] = max(son[u], siz[v]);
    }
    son[u] = max(son[u], all - siz[u]);
    if(son[u] < maxx) { maxx = son[u]; root = u; }
}
void Get_Dis(int u, int fa, int top)
{
    p[top][0].push(A_lca._Dis(father[top], u));
    for(int i=head[u], v; ~i; i=edge[i].nex)
    {
        v = edge[i].to;
        if(vis[v] || v == fa) continue;
        Get_Dis(v, u, top);
    }
}
void Divide(int u)
{
    vis[u] = true;
    int totsiz = all;
    for(int i=head[u], v; ~i; i=edge[i].nex)
    {
        v = edge[i].to;
        if(vis[v]) continue;
        all = siz[v] > siz[u] ? totsiz - siz[u] : siz[v];
        maxx = INF; root = 0;
        findroot(v, 0);
        father[root] = u;
        Get_Dis(root, 0, root);
        p[u][1].push(p[root][0].top());
        Divide(root);
    }
    p[u][1].push(0);
    if(p[u][1].size() >= 2) ans.push(p[u][1].Fir_Sec());
}
int open_num = 0;
bool open[maxN] = {false};
inline void ex_change(int x)
{
    open[x] ^= 1;
    int fa, tmp, save_x = x, lence, nexlen;
    if(open[x])
    {
        open_num++;
        fa = father[x];
        if(p[x][1].size() >= 2)
        {
            lence = p[x][1].Fir_Sec();
            ans.clear(lence);
        }
        p[x][1].clear(0);
        if(p[x][1].size() >= 2)
        {
            nexlen = p[x][1].Fir_Sec();
            ans.push(nexlen);
        }
        while(fa)
        {
            tmp = A_lca._Dis(save_x, fa);
            if(p[fa][1].size() >= 2)
            {
                lence = p[fa][1].Fir_Sec();
                ans.clear(lence);
            }
            p[fa][1].clear(p[x][0].top());
            p[x][0].clear(tmp);
            if(!p[x][0].empty()) p[fa][1].push(p[x][0].top());
            if(p[fa][1].size() >= 2)
            {
                nexlen = p[fa][1].Fir_Sec();
                ans.push(nexlen);
            }
            x = fa;
            fa = father[x];
        }
    }
    else
    {
        open_num--;
        fa = father[x];
        if(p[x][1].size() >= 2)
        {
            lence = p[x][1].Fir_Sec();
            ans.clear(lence);
        }
        p[x][1].push(0);
        if(p[x][1].size() >= 2)
        {
            nexlen = p[x][1].Fir_Sec();
            ans.push(nexlen);
        }
        while(fa)
        {
            tmp = A_lca._Dis(save_x, fa);
            if(p[fa][1].size() >= 2)
            {
                lence = p[fa][1].Fir_Sec();
                ans.clear(lence);
            }
            if(!p[x][0].empty()) p[fa][1].clear(p[x][0].top());
            p[x][0].push(tmp);
            p[fa][1].push(p[x][0].top());
            if(p[fa][1].size() >= 2)
            {
                nexlen = p[fa][1].Fir_Sec();
                ans.push(nexlen);
            }
            x = fa;
            fa = father[x];
        }
    }
}
inline void init()
{
    cnt = 0; ans.push(0);
    for(int i=1; i<=N; i++)
    {
        head[i] = -1;
        vis[i] = open[i] = false;
    }
    for(int i = 1, j = 2, k = 0; i <= (N << 1); i++)
    {
        if(i == j) { j <<= 1; k++; }
        LOG_2[i] = k;
    }
}
int main()
{
    scanf("%d", &N);
    init();
    for(int i=1, u, v; i<N; i++)
    {
        scanf("%d%d", &u, &v);
        _add(u, v);
    }
    A_lca.deep[0] = 0;
    A_lca.dfs(1, 0);
    A_lca.deep[0] = INF;
    A_lca.RMQ_Init();
    maxx = INF; root = 0; all = N;
    findroot(1, 0);
    Divide(root);
    scanf("%d", &Q);
    char op[5]; int x;
    while(Q--)
    {
        scanf("%s", op);
        if(op[0] == 'G')
        {
            if(open_num == N) printf("-1\n");
            else printf("%d\n", ans.top());
        }
        else
        {
            scanf("%d", &x);
            ex_change(x);
        }
    }
    return 0;
}

Wuliwuliii

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
动态点分治

点分治，作为树分治中的一种，在很多树形结构的问题上起到了很重要的作用，但是假如我们在树分治的基础上，根据时间戳来对树上的结点进行修改的话，那样岂不是很难受？点分治该怎么搞？暴力，当然是暴力啊？每次修改一次，我们暴力点分一次，复杂度升天。那么，就该介绍一下动态点分治了！动态点分治动态点分治，我们知道每个点分树的父节点是固定的，此话怎讲？我们模拟一下点分治的过程，首先，...
复制链接

扫一扫