Paths on the Tree【ZOJ - 3863】【点分治+推理过程】

最新推荐文章于 2022-10-16 21:49:54 发布

Wuliwuliii

最新推荐文章于 2022-10-16 21:49:54 发布

阅读量405

点赞数 1

分类专栏：思维点分治文章标签：点分治思维推理

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

版权

思维同时被 2 个专栏收录

29 篇文章 0 订阅

订阅专栏

点分治

17 篇文章 0 订阅

订阅专栏

题目链接

大致题意：有一棵N个点的树，现在取两条边，使得两条边共同都有的点的数量小于等于K，问这样的取法的种类数。
第一条边:{1, 2, 3}，第二条边:{2, 3, 4}
第一条边:{2, 3, 4}，第二条边:{1, 2, 3}
算两种方案数，同时一个点也被算作是一条边
但是{1, 2, 3}和{3, 2, 1}是一样的边（边没有方向性，无向）

解这道题，让我们先去想想看高复杂度的做法，然后再来降低复杂度维度。

首先，看一个 $O(N^2)$ 的算法，我们枚举重叠部分，也就是两条边中间的重叠部分的边，假如是如下图这样的：

我们枚举到的边的两个端点分别是X和Y（保证这条边的长度是小于等于K的），那么，我们肯定在各个点的方向上选择两个点，由X方向上的两个点和Y方向上的选择的两个点来组成一个以X-Y为重叠边的组合。

我们看X端，为了选择的两个点是以X作为结尾的，所以肯定是在X的两个不同的子树上的，那么假如X端加上X一共由size个点，那么我们一个点选取为son的话，另一个点就肯定是选取为 $size - son$ ，那么此时就是 $son * (size - son)$ ，所以选取各个son所产生的，以X点作为重叠边的一个端点时候贡献为 $\sum (son * (size - son))$ ，这里的size是X这个方向上子树的大小（包括X点），但是这里还忽略了一个很重要的情况，我们选取的两个点都是不同子树的，但是都没有考虑，选择X时候，再选一个其他点也是可行的，这时候要加上size，那么贡献实际上应该是 $\sum (son * (size - son)) + size$ 。

X端的贡献，我们看作是 $f(x) = \sum (son * (size - son)) + size$ ，那么我们枚举边X-Y时候，产生的总的贡献为 $f(x) * f(y)$ 。

对于 $f(x) = \sum (son * (size - son)) + size$ ，我们进行化简，可以得到的是 $f(x) = \sum (son * (size - son)) + size = \sum son * size - \sum son^2 + size = size * (size - 1) - \sum son^2 + size = size^2 - \sum son^2$

于是原式就被化简下来了。

那现在如何将枚举边这个麻烦而又复杂的操作从 $O(N^2)$ 降下来呢？（有点想到了楼教推荐的男人八题里的一个点分治的做法，有点久远了，以前的博客里有写到）就是用前缀和、或者后缀和的方式来维护这样具有乘法分配律的性质的信息。于是，复杂度可以升级为 $O(N * log(N))$ 。

作为点分治，就不能少了“查询到分治重心的直接相连”的情况，也就是我们需要考虑改点距离点分治重心距离 $\leq K$ 时候，与重心直接构成“枚举重叠边”的时候，我们要算其贡献，除了点分治重心的那个点是很好算的，就是通过上述的信息来计算得到，但是点分重心该如何算它的 $f(x)$ ？可以考虑成除去一棵子树v时候的贡献。那么 $f(x) = \sum_{i != v}^{ } (son_i * (size - son_i - son_v)) + size - son_v$

通过化简，可以得到 $f(x) = (size - son_v) * (size - son_v - 1) - \sum son^2 + son_v ^ 2 + size - son_v$

于是，查询到重心的直接相连边的情况就迎刃而解了。

但是，会发现一点，要是查询“小于等于K个点重叠”的情况，会发生怎样的事情呢？我们现在在点分治上向下查询的时候查到了距离重心距离为dis的点，我们需要去询问的是过重心的，在树上距离点分重心 $\leq K - dis$ 的点，分别作为“枚举的重叠边”的X-Y的两端，再利用之前求得的公式，我们可以求解此时得到的贡献值。——以上说的都是没有错的，但是这里确实要维护一个前缀和，然而每次前缀和都要维护到当前点分树的size，所以，复杂度实际上会被退化成为 $O(N^2)$ 的，但是使用后缀和，就可以完美的避开了这个雷区。因为每次更新的长度只有子树的size，这恰好就是点分治的精髓所在了。

所以，我们需要使用后缀和的方式，查询“总数-“ $>K$ ”的部分”。

总共的边数是 $sumE = \frac{N * (N + 1)}{2}$ 条

最多产生的贡献为 $sumE * sumE$

会发现一点，刚好会超过long long一丢丢，可以使用unsigned long long或者是int128来代替，快一点的话，使用unsigned long long好一些。

因为题目中给出的答案的由来是100 - 7 = 93（这里的“-7”大家可以自己推一下），所以，我用了反向思考的方式（正难则反），用了“后缀和+“查询>K””的方式来变向的求解了这个问题。

#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 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
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 9e4 + 7;
int N, K, head[maxN], cnt;
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 Const_Tree
{
    int father[maxN], size[maxN];
    void dfs(int u, int fa)
    {
        father[u] = fa; size[u] = 1;
        for(int i=head[u], v; ~i; i=edge[i].nex)
        {
            v = edge[i].to;
            if(v == fa) continue;
            dfs(v, u);
            size[u] += size[v];
        }
    }
    inline ull Real_Size(int u, int fa)
    {
        if(!fa) return size[u];
        else if(size[fa] > size[u]) return size[u];
        else return N - size[fa];
    }
} Basic_Tree;
ull ans;
struct Divide_Tree
{
    bool vis[maxN];
    int siz[maxN], son[maxN], maxx, root, all, deep[maxN], max_deep;
    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(maxx > son[u]) { maxx = son[u]; root = u; }
    }
    int num_siz[maxN], Stap[maxN], Stop;
    ull w[maxN], sum[maxN], dpsum[maxN];
    void dfs(int u, int fa, int depth)
    {
        deep[u] = depth; max_deep = max(max_deep, depth);
        num_siz[u] = 1;
        Stap[++Stop] = u;
        w[u] = Basic_Tree.Real_Size(u, fa) * Basic_Tree.Real_Size(u, fa);
        for(int i=head[u], v; ~i; i=edge[i].nex)
        {
            v = edge[i].to;
            if(v == fa) continue;
            w[u] -= Basic_Tree.Real_Size(v, u) * Basic_Tree.Real_Size(v, u);
            if(vis[v]) continue;
            dfs(v, u, depth + 1);
            num_siz[u] += num_siz[v];
        }
    }
    void work(int u)
    {
        vis[u] = true;
        if(all <= K) return;
        int totsiz = all;
        for(int i=0; i<=all; i++) sum[i] = 0;
        ull fang = 0, cop_N = N;
        for(int i=head[u], v; ~i; i=edge[i].nex)
        {
            v = edge[i].to;
            fang += Basic_Tree.Real_Size(v, u) * Basic_Tree.Real_Size(v, u);
        }
        for(int i=head[u], v; ~i; i=edge[i].nex)
        {
            v = edge[i].to;
            if(vis[v]) continue;
            Stop = 0;
            dfs(v, u, 1);
            for(int j=0; j<=num_siz[v]; j++) dpsum[j] = 0;
            for(int j=1; j<=Stop; j++) dpsum[deep[Stap[j]]] += w[Stap[j]];
            for(int j=1; j<=num_siz[v]; j++)
            {
                if(K - j <= totsiz)
                {
                    ans += sum[max(0, K - j)] * dpsum[j];
                }
            }
            for(int j=num_siz[v] - 1; j>=0; j--) dpsum[j] += dpsum[j + 1];
            if(K < num_siz[v] + 1) ans += dpsum[K] * ((cop_N - Basic_Tree.Real_Size(v, u)) * (cop_N - Basic_Tree.Real_Size(v, u) - 1) - fang + Basic_Tree.Real_Size(v, u) * Basic_Tree.Real_Size(v, u) + cop_N - Basic_Tree.Real_Size(v, u));
            for(int j=num_siz[v]; j>=0; j--) sum[j] += dpsum[j];
        }
        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;
            findroot(v, 0);
            work(root);
        }
    }
    inline void clear()
    {
        for(int i=1; i<=N; i++) { vis[i] = false; sum[i] = 0; }
    }
} DT;
inline void init()
{
    cnt = 0; DT.clear();
    for(int i=1; i<=N; i++) head[i] = -1;
}
int main()
{
    int T; scanf("%d", &T);
    while(T--)
    {
        scanf("%d%d", &N, &K);
        init();
        for(int i=1, u, v; i<N; i++)
        {
            scanf("%d%d", &u, &v);
            _add(u, v);
        }
        Basic_Tree.dfs(1, 0);
        ans = 0;
        DT.maxx = INF; DT.all = N; DT.max_deep = 0;
        DT.findroot(1, 0);
        DT.work(DT.root);
        ull sumE = (ull)N * (N + 1) / 2;
        printf("%llu\n", sumE * sumE - ans);
    }
    return 0;
}

Wuliwuliii

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Paths on the Tree【ZOJ - 3863】【点分治+推理过程】

题目链接大致题意：有一棵N个点的树，现在取两条边，使得两条边共同都有的点的数量小于等于K，问这样的取法的种类数。第一条边:{1, 2, 3}，第二条边:{2, 3, 4}第一条边:{2, 3, 4}，第二条边:{1, 2, 3}算两种方案数，同时一个点也被算作是一条边但是{1, 2, 3}和{3, 2, 1}是一样的边（边没有方向性，无向）解这道题，让我们先去想想看高复杂度...
复制链接

扫一扫