bzoj1758 [Wc2010]重建计划(二分答案+点分治+单调栈)

首先求一个最优比率的东西,我们二分答案,转化成判定是否存在一条合法路径使得边权和≥0.然后这个东西我们点分治去做。每次计算过x的合法路径的最大值时,为了避免不合法,我们一个子树一个子树的做。我们处理出g[i],表示目前这棵子树深度为i的点的最大距离,tmp[i]表示之前做过的子树深度为i的点的最大距离。我们每次用g[i]去询问tmp,也就是要在tmp[l-i,r-i]中选一个最大值,我们发现这就是一个滑动的窗口,可以用单调队列来维护。然后为了保证复杂度,我们要按子树深度(大小)从小到大来做。清零要手动清。为了卡常,我们二分答案要在每次分治里面分,最小值直接从ans开始枚举,子树大小< L时就可以不做了。再次不得不orz leoly

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <utility>
using namespace std;
#define ll long long
#define inf 1e20
#define N 100010
#define eps 1e-4
#define pa pair<double,int>
inline int read(){
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
    return x*f;
}
int n,L,R,h[N],num=0,sz[N],sumsz,f[N],dep[N],mxdep,fa[N],rt,sonnum=0;
double mid,dis[N],g[N],tmp[N],ans=0;bool vis[N];
struct edge{
    int to,next,val;
}data[N<<1];
struct Son{
    int id,val;
}son[N];
inline bool cmp(Son x,Son y){return sz[x.id]<sz[y.id];}
void dfs1(int x){
    sz[x]=1;
    for(int i=h[x];i;i=data[i].next){
        int y=data[i].to;if(y==fa[x]||vis[y]) continue;
        fa[y]=x;dep[y]=dep[x]+1;dfs1(y);sz[x]+=sz[y];
    }
}
void dfs2(int x){
    f[x]=0;
    for(int i=h[x];i;i=data[i].next){
        int y=data[i].to;if(y==fa[x]||vis[y]) continue;
        dfs2(y);f[x]=max(f[x],sz[y]);
    }f[x]=max(f[x],sumsz-sz[x]);if(f[x]<f[rt]) rt=x;
}
inline void dfs3(int x){
    g[dep[x]]=max(g[dep[x]],dis[x]);mxdep=max(mxdep,dep[x]);
    for(int i=h[x];i;i=data[i].next){
        int y=data[i].to;if(y==fa[x]||vis[y]) continue;
        dis[y]=dis[x]+data[i].val-mid;dfs3(y);
    }
}
inline bool jud(int x){
    int mx=0;tmp[0]=0;deque<pa>q;bool flag=0;
    for(int ii=1;ii<=sonnum;++ii){
        int y=son[ii].id;if(vis[y]) continue;
        dis[y]=son[ii].val-mid;mxdep=0;dfs3(y);
        int now=L-mxdep;if(now<0) now=0;
        for(int i=mxdep;i>=1;--i){
            while(now<=mx&&now+i<=R){
                while(!q.empty()&&tmp[now]>q.back().first) q.pop_back();
                q.push_back(make_pair(tmp[now],now));++now;
            }while(!q.empty()&&q.front().second+i<L) q.pop_front();
            if(!q.empty()&&q.front().first+g[i]>=-eps){flag=1;break;}
        }for(int i=mxdep;i>=1;--i)
            tmp[i]=max(tmp[i],g[i]),g[i]=-inf;mx=max(mx,mxdep);
        if(flag) break;
    }for(int i=0;i<=mx;++i) tmp[i]=-inf;
    return flag;
}
inline void solve(int x){
    vis[x]=1;fa[x]=0;dep[x]=0;dfs1(x);
    if(sz[x]<L) return;
    double l=ans,r=1000000;sonnum=0;
    for(int i=h[x];i;i=data[i].next){
        int y=data[i].to;if(vis[y]) continue;son[++sonnum].id=y;
        son[sonnum].val=data[i].val;
    }sort(son+1,son+sonnum+1,cmp);
    while(r-l>eps){
        mid=(r+l)/2;
        if(jud(x)) l=mid;else r=mid;
    }ans=l;
    for(int i=h[x];i;i=data[i].next){
        int y=data[i].to;if(vis[y]) continue;
        rt=0;sumsz=sz[y];dfs2(y);solve(rt);
    }
}
int main(){
//  freopen("rebuild8.in","r",stdin);
//  freopen("rebuild.out","w",stdout);
    n=read();L=read();R=read();f[0]=n+1;
    for(int i=1;i<n;++i){
        int x=read(),y=read(),val=read();
        data[++num].to=y;data[num].next=h[x];h[x]=num;data[num].val=val;
        data[++num].to=x;data[num].next=h[y];h[y]=num;data[num].val=val;
    }
    for(int i=0;i<=n;++i) g[i]=tmp[i]=-inf;
    dfs1(1);rt=0;sumsz=n;dfs2(1);solve(rt);
    printf("%.3lf\n",ans);
    return 0;
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,这是一道经典的单调栈问题。题目描述如下: 有 $n$ 个湖,第 $i$ 个湖有一个高度 $h_i$。现在要在这些湖之间挖一些沟渠,使得相邻的湖之间的高度差不超过 $d$。请问最少需要挖多少个沟渠。 这是一道单调栈的典型应用题。我们可以从左到右遍历湖的高度,同时使用一个单调栈来维护之前所有湖的高度。具体来说,我们维护一个单调递增的栈,栈中存储的是湖的下标。假设当前遍历到第 $i$ 个湖,我们需要在之前的湖中找到一个高度最接近 $h_i$ 且高度不超过 $h_i-d$ 的湖,然后从这个湖到第 $i$ 个湖之间挖一条沟渠。具体的实现可以参考下面的代码: ```c++ #include <cstdio> #include <stack> using namespace std; const int N = 100010; int n, d; int h[N]; stack<int> stk; int main() { scanf("%d%d", &n, &d); for (int i = 1; i <= n; i++) scanf("%d", &h[i]); int ans = 0; for (int i = 1; i <= n; i++) { while (!stk.empty() && h[stk.top()] <= h[i] - d) stk.pop(); if (!stk.empty()) ans++; stk.push(i); } printf("%d\n", ans); return 0; } ``` 这里的关键在于,当我们遍历到第 $i$ 个湖时,所有比 $h_i-d$ 小的湖都可以被舍弃,因为它们不可能成为第 $i$ 个湖的前驱。因此,我们可以不断地从栈顶弹出比 $h_i-d$ 小的湖,直到栈顶的湖高度大于 $h_i-d$,然后将 $i$ 入栈。这样,栈中存储的就是当前 $h_i$ 左边所有高度不超过 $h_i-d$ 的湖,栈顶元素就是最靠近 $h_i$ 且高度不超过 $h_i-d$ 的湖。如果栈不为空,说明找到了一个前驱湖,答案加一。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值