[Luogu P4292] [BZOJ 1758] [WC2010]重建计划

最新推荐文章于 2022-02-17 20:38:09 发布

LPA20020220

最新推荐文章于 2022-02-17 20:38:09 发布

阅读量251

点赞数 1

分类专栏：点分树点分治单调队列文章标签：点分树点分治单调队列

本文链接：https://blog.csdn.net/LPA20020220/article/details/80778461

版权

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

7 篇文章 0 订阅

订阅专栏

点分树

4 篇文章 0 订阅

订阅专栏

单调队列

4 篇文章 0 订阅

订阅专栏

题目描述

X国遭受了地震的重创, 导致全国的交通近乎瘫痪，重建家园的计划迫在眉睫。X国由 $N$ 个城市组成, 重建小组提出，仅需建立 $N-1$ 条道路即可使得任意两个城市互相可达。于是，重建小组很快提出了一个包含 $N-1$ 条道路的方案，并满足城市之间两两可达，他们还计算评估了每条道路 $e$ 建设之后可以带来的价值 $v(e)$ 。
由于重建计划复杂而艰难，经费也有一定限制。因此，政府要求第一期重建工程修建的道路数目为 $k$ 条，但需满足 $L ≤ k ≤ U$ , 即不应少于 $L$ 条，但不超过 $U$ 条。同时，为了最大化利用率，要求建设的这些道路恰好组成一条简单路径，即所建设的 $k$ 条路径可以构成一个排列 $e_1 = (p_1, q_1), e_2 = (p_2, q_2), ... e_k = (p_k, q_k)$ , 对于 $1 ≤ i < k$ , 有( $q_i = p_i+1$ )。

重建小组打算修改他们的原有方案以满足要求，即在原有的 $N-1$ 条道路中寻找一条路径 $S$ 作为新的方案，使得新方案中的道路平均价值

A v g V a l u e = \frac{\sum_{e \in S} v (e)}{| S |}

$AvgValue=\frac{\sum_{e \in S}v(e)}{|S|}$
最大。这里

v(e) v ( e ) $v(e)$ 表示道路

e e $e$ 的价值，

| S |

$|S|$ 表示新方案中道路的条数。请你帮助重建小组寻找一个最优方案。注: 在本题中

L L $L$ 和

U

$U$ 的设置将保证有解。

输入输出格式

输入格式：

第一行包含一个正整数 $N$ ，表示X国的城市个数。
第二行包含两个正整数 $L$ 、 $U$ ，表示政府要求的第一期重建方案中修建道路数的上下限。
接下来的 $N-1$ 行描述重建小组的原有方案，每行三个正整数 $a_i, b_i, v_i$ ，分别表示道路 $(a_i, b_i)$ ，其价值为 $v_i$ 。其中城市由 $1…N$ 标号。

输出格式：

仅包含一行，为一个实数 $AvgValue$ ，即最大平均价值。
小数点后保留三位。

输入输出样例

输入样例#1：

输出样例#1：

2.500

说明

新方案中选择路径 $(3, 1)$ , $(1, 4)$ 可以得到的平均价值为 $2.5$ ，为最大平均价值。
对于 $20\%$ 的数据， $N ≤ 5 000$ ;
另有 $30\%$ 的数据， $N ≤ 100 000$ , 原有方案恰好为一条路径(链);
对于 $100\%$ 的数据， $N ≤ 100 000, 1 ≤ L ≤ U ≤ N-1, v_i ≤ 10^6$ 。

解题分析

保留三位小数和4s的时限这些条件可以看出这道题是二分答案+点分树，然后博主就不会做了…
搜了搜题解，发现此题是一道分数规划问题。
最简单无脑不需二分的想法是直接做一遍点分，同时对经过分治重心的边暴力更新。但这样搞是每一层 $O(N^2)$ ，总复杂度达到了 $O(N^2log^2(N))$ 显然不可过。
在这道题中，我们想要求得一条路径使得其平均值最大，那么可以二分这个平均值 $AveValve$ ，将所有边的边权减去这个二分得到的值。如果一条路径长度位于 $[L,U]$ 之间且边权和大于0，则说明这个值是可行的。
现在我们有一个 $O(Nlog^3(N))$ 的做法。对于每个分治重心，我们考虑用线段树维护到分治重心距离为 $x$ 的点的边权前缀和最大值。对于每一个在子树上的点 $D$ ，设其深度为 $dep$ ，则在线段树上对应一段区间为 $[L-dep, U-dep]$ ，我们只需要查区间最大值即可。
但经网上大神们实验，这个复杂度也是过不去的… 我们需要一个 $O(N)$ 更新一层分治重心的算法。
上面我们说到了，每一个子树上的点有唯一对应的一段查询区间，并且这个区间随子树上点深度的增大而向更小方向移动。这样具有单调性的查询可以用单调队列来优化至 $(O(N))$ 。
还有很多卡常的小细节，其实做到了常数并不大，详见代码。

#include <cstdio>
#include <algorithm>
#include <cctype>
#include <cstdlib>
#include <cstring>
#include <cmath>
#define R register
#define W while
#define gc getchar()
#define db double
#define IN inline
#define EPS 1e-4
#define INF 1e12
#define MX 200005
bool neg;
template <class T>
IN void in(T &x)
{
    x = 0; R char c = gc;
    W (!isdigit(c)) {if(c == '-') neg = true; c = gc;}
    W (isdigit(c))
    x = (x << 1) + (x << 3) + c - 48, c = gc;
    if(neg) neg = false, x = -x;
}
db ans, len[MX], rec[MX];
int dot, D, U, cnt, deal, root, ub, dpmx, cot;
int dep[MX], fat[MX], siz[MX], mx[MX], que[MX],
sub[MX], ds[MX], q[MX], head[MX], far[MX];
bool vis[MX];
IN bool cmp(const int &x, const int &y)
{return far[x] < far[y];}
struct Edge
{
    int to, len, nex;
}edge[MX << 1];
IN void addedge(const int &from, const int &to, const int &len)
{
    edge[++cnt] = {to, len, head[from]};
    head[from] = cnt;
}
namespace FP
{
    IN bool check(const int &cent, const db &cut)
    {
        R int lb, rb, hd, tl, now, dl;
        dpmx = 0;
        for (R int t = 1; t <= cot; ++t)
        {
            if(vis[sub[t]]) continue;
            que[hd = tl = 0] = sub[t];
            dep[sub[t]] = 1;
            len[sub[t]] = ds[sub[t]] - cut;
            fat[sub[t]] = cent;
            W (hd <= tl)
            {
                now = que[hd++];
                for (R int i = head[now]; i; i = edge[i].nex)
                //BFS一遍， 在队列中点深度不降
                {
                    if(edge[i].to == fat[now] || vis[edge[i].to]) continue;
                    que[++tl] = edge[i].to, fat[edge[i].to] = now,
                    dep[edge[i].to] = dep[now] + 1, len[edge[i].to] = edge[i].len + len[now] - cut;
                }
            }
            lb = 1, rb = 0, dl = dpmx;//dpmx指处理的所有子树中最深的深度
            for (R int i = 0; i <= tl; ++i)
            {
                now = que[i];
                W (dl >= 0 && dl + dep[now] >= D)//更新能够加入队列的最大值
                {
                    W (lb <= rb && rec[q[rb]] <= rec[dl]) --rb;
                    q[++rb] = dl, --dl;
                }
                W (lb <= rb && dep[now] + q[lb] > U) ++lb;//处理超过上限的部分
                if(lb <= rb && len[now] + rec[q[lb]] >= EPS) return true;
            }
            for (R int i = dpmx + 1; i <= dep[que[tl]]; ++i) rec[i] = -INF;//多出的部分赋为新值
            for (R int i = 0; i <= tl; ++i) rec[dep[que[i]]] = std::max(rec[dep[que[i]]], len[que[i]]);//更新最优答案
            dpmx = std::max(dpmx, dep[que[tl]]);
        }
        return false;
    }
}
namespace Dtdv
{
    void DFS(const int &now, const int &fa, const int &fr)
    {//far 存子树最大深度， 方便分数规划时对子树排序
        siz[now] = 1; far[now] = fr;
        for (R int i = head[now]; i; i = edge[i].nex)
        {
            if(vis[edge[i].to] || edge[i].to == fa) continue;
            DFS(edge[i].to, now, fr + 1);
            siz[now] += siz[edge[i].to];
            far[now] = std::max(far[now], far[edge[i].to]);
        }
    }
    void getroot(const int &now, const int &fa)
    {
        mx[now] = 0;
        for (R int i = head[now]; i; i = edge[i].nex)
        {
            if(vis[edge[i].to] || edge[i].to == fa) continue;
            getroot(edge[i].to, now);
            mx[now] = std::max(mx[now], siz[edge[i].to]);
        }
        mx[now] = std::max(mx[now], deal - siz[now]);
        if(mx[now] < mx[root]) root = now;
    }
    void solve(R int now)
    {
        DFS(now, 0, 0); cot = 0;
        for (R int i = head[now]; i; i = edge[i].nex)
        {
            if(vis[edge[i].to]) continue;
            sub[++cot] = edge[i].to, ds[edge[i].to] = edge[i].len;//ds存分治重心到子树上第一个节点的距离
        }
        std::sort(sub + 1, sub + 1 + cot, cmp);
        db dn = ans, up = ub, mid;
        W (233)//二分确定答案
        {
            if(up - dn < EPS) break;
            mid = (up + dn) / 2.0;
            if(FP::check(now, mid)) dn = mid; 
            else up = mid;
        }
        ans = dn; vis[now] = true;
        for (R int i = head[now]; i; i = edge[i].nex)
        {
            if(vis[edge[i].to]) continue;
            DFS(edge[i].to, 0, 0);
            mx[root = 0] = deal = siz[edge[i].to];
            if(siz[edge[i].to] < D) continue;
            getroot(edge[i].to, 0);
            solve(root);
        }
    }
}
int main(void)
{
    int a, b, c;
    in(dot), in(D), in(U);
    for (R int i = 1; i < dot; ++i) 
    in(a), in(b), in(c), addedge(a, b, c), addedge(b, a, c), ub = std::max(ub, c);//提前确定二分上界， 减少二分次数
    Dtdv::DFS(1, 0, 0);
    mx[root = 0] = deal = siz[1];
    Dtdv::getroot(1, 0);
    Dtdv::solve(root);
    printf("%.3lf", ans);
}

LPA20020220

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
[Luogu P4292] [BZOJ 1758] [WC2010]重建计划

BZOJ 传送门洛谷传送门题目描述X国遭受了地震的重创, 导致全国的交通近乎瘫痪，重建家园的计划迫在眉睫。X国由NNN个城市组成, 重建小组提出，仅需建立N−1N−1N-1条道路即可使得任意两个城市互相可达。于是，重建小组很快提出了一个包含N−1N−1N-1条道路的方案，并满足城市之间两两可达，他们还计算评估了每条道路eee建设之后可以带来的价值v(e)v(e)v(e)。由于重建计...
复制链接

扫一扫