NOIP2015 运输计划 - 二分 + 树链剖分 / （倍增 + 差分）

最新推荐文章于 2019-10-07 10:25:55 发布
最新推荐文章于 2019-10-07 10:25:55 发布
阅读量115 收藏
点赞数
原文链接：http://www.cnblogs.com/CzYoL/p/7674562.html
版权

BZOJ

CodeVS

Uoj

题目大意：

给一个n个点的边带权树，给定m条链，你可以选择树中的任意一条边，将它置为0，使得最长的链长最短。

题目分析：

最小化最大值，二分。

二分最短长度mid，将图中链长大于mid的链提取出来，求他们的交路径，选择他们都经过最大的一条边，看是否满足要求。
这是基本思路，下面来想想如何求解：一共尝试了两种办法：

  • 倍增lca / 树链剖分lca + 树上差分： 求lca部分略过（本题用链剖较快），对于一条u->v的路径，在u处+1，v处+1，lca处-2，从下往上求后缀和，即可得到i->fa[i]这条边被经过的次数，假设二分时选出了k条边，那么选择一条经过次数==k的边权最大的边，来判断是否满足。

  • 树链剖分 + 线段树：将u->v上每个节点+1，选出所有的边后，在线段树上将标记下放到底层（节点），如果该节点i（代表i->fa[i]这条边）值为k，更新边权最大值。最后用这个最大值来判断是否满足。注意:pathModify时，最后一步modify时不能改lca（看代码吧，一言难尽，仔细脑补），因为lca代表的边不是这条路径上的。

大优化： 开一个记忆化数组memory，记录选出最大的k条边时的最大权值和，可以加速很多。

ps: 被uoj的extra test hack掉了。

code

树链lca + 树上差分：

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;

namespace IO{
    inline ll read(){
        ll i = 0, f = 1; char ch = getchar();
        for(; (ch < '0' || ch > '9') && ch != '-'; ch = getchar());
        if(ch == '-') f = -1, ch = getchar();
        for(; ch >= '0' && ch <= '9'; ch = getchar()) i = (i << 3) + (i << 1) + (ch - '0');
        return i * f;
    }
    inline void wr(ll x){
        if(x < 0) putchar('-'), x = -x;
        if(x > 9) wr(x / 10);
        putchar(x % 10 + '0');
    }
}using namespace IO;

typedef long long ll;
const int N = 3e5 + 5, M = 3e5 + 5, OO = 0x3f3f3f3f;
int n, m, ecnt, adj[N], nxt[N << 1], go[N << 1];
int dep[N], sum[N], fa[N], sze[N], idx[N], pos[N], tot, son[N], top[N];
ll ans, len[N << 1], l = OO, r, dis[N], val[N], memory[M];
struct node{
    int u, v;
    ll tt;
    inline bool operator < (const node &b) const{return tt < b.tt;}
}plan[M];

inline void addEdge(int u, int v, ll t){nxt[++ecnt] = adj[u], adj[u] = ecnt, go[ecnt] = v, len[ecnt] = t;}

inline int getLca(int u, int v){
    while(top[u] != top[v]){
        if(dep[top[u]] < dep[top[v]]) swap(u, v);
        u = fa[top[u]];
    }
    if(u == v) return u;
    return dep[u] < dep[v] ? u : v;
}

inline void dfs1(int u, int f){
    dep[u] = dep[f] + 1, fa[u] = f, sze[u] = 1;
    for(int e = adj[u], v; e; e = nxt[e]){
        if((v = go[e]) == f) continue;
        dis[v] = dis[u] + len[e], val[v] = len[e], dfs1(v, u), sze[u] += sze[v];
        if(sze[v] > sze[son[u]]) son[u] = v;
    }
}

inline void dfs2(int u, int f){
    if(son[u]){
        idx[pos[son[u]] = ++tot] = son[u];
        top[son[u]] = top[u];
        dfs2(son[u], u);
    }
    for(int v, e = adj[u]; e; e = nxt[e]){
        if((v = go[e]) == f || v == son[u]) continue;
        top[v] = v;
        idx[pos[v] = ++tot] = v;
        dfs2(v, u);
    }
}

inline void getSum(int u, int f){
    for(int v, e = adj[u]; e; e = nxt[e]){
        if((v = go[e]) == f) continue;
        getSum(v, u);
        sum[u] += sum[v];
    }
}

inline bool check(ll mid){
    memset(sum, 0, sizeof sum); int cnt = 0;
    for(int i = m; i >= 1; i--){
        if(plan[i].tt <= mid) break;
        cnt++, sum[plan[i].u]++, sum[plan[i].v]++, sum[getLca(plan[i].u, plan[i].v)] -= 2;
    }
    if(memory[cnt])
        return plan[m].tt - memory[cnt] <= mid;
    getSum(1, 0); 
    ll maxx = 0;
    for(int i = 1; i <= n; i++) if(sum[i] == cnt) maxx = max(maxx, val[i]);
    memory[cnt] = maxx;
    return plan[m].tt - maxx <= mid;
}

inline void solve(){
    l = 0, r = plan[m].tt;
    while(l <= r){
        ll mid = l + r >> 1;
        if(check(mid)) ans = mid, r = mid - 1;
        else l = mid + 1;
    }
}

int main(){
    n = read(), m = read();
    for(int i = 1; i < n; i++){
        int x = read(), y = read(); ll t = 1ll*read(); 
        addEdge(x, y, t), addEdge(y, x, t);
    } 
    pos[1] = top[1] = idx[1] = tot = 1, dfs1(1, 0), dfs2(1, 0);
    for(int i = 1; i <= m; i++) plan[i].u = read(), plan[i].v = read(), plan[i].tt = dis[plan[i].u] + dis[plan[i].v] - 2 * dis[getLca(plan[i].u, plan[i].v)];
    sort(plan + 1, plan + m + 1);
    solve();
    wr(ans), putchar('\n');
    return 0;
}

树链剖分 + 线段树：

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;

namespace IO{
    inline ll read(){
        ll i = 0, f = 1; char ch = getchar();
        for(; (ch < '0' || ch > '9') && ch != '-'; ch = getchar());
        if(ch == '-') f = -1, ch = getchar();
        for(; ch >= '0' && ch <= '9'; ch = getchar()) i = (i << 3) + (i << 1) + (ch - '0');
        return i * f;
    }
    inline void wr(ll x){
        if(x < 0) putchar('-'), x = -x;
        if(x > 9) wr(x / 10);
        putchar(x % 10 + '0');
    }
}using namespace IO;

typedef long long ll;
const int N = 3e5 + 5, M = 3e5 + 5, OO = 0x3f3f3f3f;
int n, m, ecnt, adj[N], nxt[N << 1], go[N << 1];
int dep[N], sum[N], fa[N], sze[N], idx[N], pos[N], tot, son[N], top[N];
ll ans, len[N << 1], l = OO, r, dis[N], val[N], memory[M];
struct node{
    int u, v;
    ll tt;
    inline bool operator < (const node &b) const{return tt < b.tt;}
}plan[M];

namespace SegTree{
    int tree[N << 2], tag[N << 2];
    inline void upt(int k){tree[k] = tree[k << 1] + tree[k << 1 | 1];}
    inline void add(int k, int l, int r, int v){tree[k] += (r - l + 1) * v, tag[k] += v;}
    inline void modify(int k, int l, int r, int x, int y){
        if(x <= l && r <= y){add(k, l, r, 1);return;}
        int mid = l + r >> 1, lc = k << 1, rc = k << 1 | 1;
        if(x <= mid) modify(lc, l, mid, x, y);
        if(y > mid) modify(rc, mid + 1, r, x, y);
        upt(k);
    }
    inline void pushDown(int k, int l, int r){if(tag[k]) add(k << 1, l, l + r >> 1, tag[k]), add(k << 1 | 1, (l + r >> 1) + 1, r, tag[k]), tag[k] = 0;}
    inline void pushToTheEnd(int k, int l, int r, ll v, ll &maxx){
        if(l == r){if(tree[k] == v) maxx = max(maxx, val[idx[l]]);return;}
        int mid = l + r >> 1, lc = k << 1, rc = k << 1 | 1;
        pushDown(k, l, r);
        pushToTheEnd(lc, l, mid, v, maxx);
        pushToTheEnd(rc, mid + 1, r, v, maxx);
    }
}using namespace SegTree;

inline void addEdge(int u, int v, ll t){nxt[++ecnt] = adj[u], adj[u] = ecnt, go[ecnt] = v, len[ecnt] = t;}

inline int getLca(int u, int v){
    while(top[u] != top[v]){
        if(dep[top[u]] < dep[top[v]]) swap(u, v);
        u = fa[top[u]];
    }
    if(u == v) return u;
    return dep[u] < dep[v] ? u : v;
}

inline void dfs1(int u, int f){
    dep[u] = dep[f] + 1, fa[u] = f, sze[u] = 1;
    for(int e = adj[u], v; e; e = nxt[e]){
        if((v = go[e]) == f) continue;
        dis[v] = dis[u] + len[e], val[v] = len[e], dfs1(v, u), sze[u] += sze[v];
        if(sze[v] > sze[son[u]]) son[u] = v;
    }
}

inline void dfs2(int u, int f){
    if(son[u]){
        idx[pos[son[u]] = ++tot] = son[u];
        top[son[u]] = top[u];
        dfs2(son[u], u);
    }
    for(int v, e = adj[u]; e; e = nxt[e]){
        if((v = go[e]) == f || v == son[u]) continue;
        top[v] = v;
        idx[pos[v] = ++tot] = v;
        dfs2(v, u);
    }
}

inline void pathModify(int u, int v){
    while(top[u] != top[v]){
        if(dep[top[u]] < dep[top[v]]) swap(u, v);
        modify(1, 1, n, pos[top[u]], pos[u]);
        u = fa[top[u]];
    }
    if(dep[u] > dep[v]) swap(u, v);
    modify(1, 1, n, pos[son[u]], pos[v]);
}

inline bool check(ll mid){
    int cnt = 0;
    memset(tree, 0, sizeof tree);
    memset(tag, 0, sizeof tag);
    for(int i = m; i >= 1; i--){
        if(plan[i].tt <= mid) break;
        cnt++;
    }
    if(memory[cnt])
        return plan[m].tt - memory[cnt] <= mid; 
    for(int i = m; i >= m - cnt + 1; i--) pathModify(plan[i].u, plan[i].v);
    ll maxx = 0;
    pushToTheEnd(1, 1, n, cnt, maxx);
    memory[cnt] = maxx;
    return plan[m].tt - maxx <= mid;
}

inline void solve(){
    l = 0, r = plan[m].tt;
    while(l <= r){
        ll mid = l + r >> 1;
        if(check(mid)) ans = mid, r = mid - 1;
        else l = mid + 1;
    }
}

int main(){
    n = read(), m = read();
    for(int i = 1; i < n; i++){
        int x = read(), y = read(); ll t = 1ll*read(); 
        addEdge(x, y, t), addEdge(y, x, t);
    } 
    pos[1] = top[1] = idx[1] = tot = 1, dfs1(1, 0), dfs2(1, 0);
    for(int i = 1; i <= m; i++) plan[i].u = read(), plan[i].v = read(), plan[i].tt = dis[plan[i].u] + dis[plan[i].v] - 2 * dis[getLca(plan[i].u, plan[i].v)];
    sort(plan + 1, plan + m + 1); 
    solve();
    wr(ans), putchar('\n');
    return 0;
}

转载于:https://www.cnblogs.com/CzYoL/p/7674562.html

badiu_30394251
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
HDU 5044 Tree 树链剖分+差分
noone0的博客
09-16 245
题意:n点m条边的带权树,点边都带权，Q次操作. op1:将u,v路径上所有点的权值加k. op2:将u,v路径上所有边的权值加k. n,m 操作为区间+,查询只要最后一次,可以不用线段树,破树成链以后,用两个数组差分一下就好了. #pragma comment(linker, "/STACK:1024000000,1024000000") #include usin
NOIP 树链剖分 NOIP 树链剖分
10-30
### NOIP 树链剖分知识点详解 #### 一、树链剖分的相关概念 **剖分目的**：树链剖分的主要目的是为了更高效地处理树状结构上的路径信息维护问题，例如路径上的权值更新或查询等操作。通过树链剖分，可以将这些操作...
3011: Running Away From the Barn 可并堆/倍增+树链剖分+树上差分/dfs序+主席树
TYB的博客
03-09 228
Description 给出以1号点为根的一棵有根树，问每个点的子树中与它距离小于**等于**l的点有多少个。 题解： 这道题本来是我在学可并堆的时候找到的，但是我并没有想出可并堆的做法，下面提供三种做法。 1、可并堆 首先预处理出每个点到根的距离v[x]v[x]v[x]，然后以此为关键字对每个节点先建个大根堆，然后dfs一次，每次把所有儿子和自己合并，然后一直删堆顶，直到满足条件为...
codeforces 191C Fools and Roads (树链剖分 或 树上差分) HQG_AC 的博客
Hacheylight
04-28 223
#include &amp;lt;bits/stdc++.h&amp;gt; using namespace std ; const int N = 100000 + 10 ; struct node{ int v,next,en ; }e[2*N]; int cf[N] ; int ans[N] ; bool vis[N] ; int tot,a,b,n,u,v,k ; int head[N],deep...
【NOIP2015】运输计划 差分数组+线段树+树链剖分
Qantun_Mechanics的博客
04-27 3542
最开始考NOIP的时候看到这个题目写了个SPFA，写搓了一分都没有，后来学了不少新姿势以后重新想起了这个题目据说倍增可以水60分，额，想了一想不知道怎么弄，于是我就开始写可以A的算法了，别人告诉我这个题目会被卡常数，有点慌 好吧后来除了二分边界错了并没有被卡常数，可能是因为我最开始就注意压缩常数了吧。 BZOJ：http://www.lydsy.com/JudgeOnline/problem.p
NOIP2015 运输计划 LCA+树上差分+二分
DyingShu的博客
08-18 179
题目大意：给定一棵树，再给定k条路径，求把一条边权改为0后使这些路径的最长距离最小。 题解：首先可以想到用二分（谁说想得到的！！！），在枚举出来的长度mid上找到长度大于mid的路径，检查把这些路径中最长的公共边置为0之后的最长链。若长度还是大于mid，则该长度不合法。实际编码中，可以用树上差分来解决边覆盖的问题。 我用倍增写的LCA，如果换成树链剖分或者Tarjan，RMQ什么的会更快~ ...
LCA+二分+树上差分——Luogu2680 [NOIP2015]运输计划
2333：jzqjzq的博客专栏
10-03 245
题面：luogu2680 真受不了。。。这么多人AC的一道题目又花了我一个晚上时间做QAQ 所以这种题目就是近年来NOIP压轴题（也不一定是压轴题）的命题趋势？ 13年的货车运输，15年的运输计划，16年的天天爱跑步，所以17年会是啥？ 如果是这样，NOIP考场上这种题我还能在考试时间内切掉么？简要思路： 首先我们肯定要求的给出的计划的LCA和距离啦（这个随便你怎么求） 接下来我们二
NOIP2015 T6 运输计划 【树上差分】
cdsszjj的博客
10-20 292
解题思路：这道题空找一条边不好找，注意到他是使最大的最小，所以不妨考虑二分答案。 设二分的答案为t，则对于每一条len>td的链，必须要修改其上的一条边。如果共要修改m条链，那么修改的那条边一定是这m条链的交集，那么问题就变成了求m条链的交集，看最长减去交集中最长的一条边是否小于t； 那如何求交集呢？可以用树上差分： 设tag[v]表示m条链经过（v,fa[v]）这条边的次数，对于每条链（x,
洛谷P2680运输计划——二分+lca+树上差分
qq_36314344的博客
10-07 195
题目：https://www.luogu.org/problem/P2680 分析：二分答案+倍增+树上差分 题目实质：给定一棵树和一些点对，将一条边的权值变为0，使点对最大距离最小并求出最小距离。 1、因为是求最大距离的最小值，所以很自然地想到二分答案法。 2、怎样求点对距离？需要求出lca。求lca有三个方法：一是倍增；二是树链剖分；三是Tarjan。 dfs求出树上每个点到根节点的...
Luogu 2680 NOIP 2015 运输计划（树链剖分，LCA，树状数组，树的重心，二分，差分）...
dipinzhu4111的博客
10-05 176
Luogu 2680 NOIP 2015 运输计划（树链剖分，LCA，树状数组，树的重心，二分，差分） Description L 国有 n 个星球,还有 n-1 条双向航道,每条航道建立在两个星球之间,这 n-1 条航道连通了 L 国的所有星球。 小 P 掌管一家物流公司,该公司有很多个运输计划,每个运输计划形如:有一艘物 流飞船需要从 ui 号星球沿最快的宇航路径飞行到 vi 号星球...
NOIP树链剖分习题讲解报告
11-01
### NOIP树链剖分习题讲解报告 #### P2590 [ZJOI2008]树的统计 **题目概述：** 本题给出了一棵树，包含`n`个节点，每个节点有一个权值`w`。任务是对这棵树进行一系列的操作，并根据这些操作回答一些查询问题。具体...
NOIP2006-2018初赛+2019CSP-J CSP-S初赛（2020.09.27）.rar
09-27
NOIP2006-2018初赛+2019CSP-J CSP-S初赛（2020.09.27） NOIP2006-2018初赛+2019CSP-J CSP-S初赛（2020.09.27） NOIP2006-2018初赛+2019CSP-J CSP-S初赛（2020.09.27） NOIP2006-2018初赛+2019CSP-J CSP-S初赛（2020....
NOIP初赛 CSP-J1 CSP-S1 第1轮 初赛 信奥中的数学知识（C).pdf
07-02
NOIP初赛 CSP-J1 CSP-S1 第1轮 初赛 信奥中的数学知识 NOIP初赛 CSP-J1 CSP-S1 第1轮 初赛 信奥中的数学知识是指中国全国青少年信息学奥林匹克联赛（NOIP）的初赛数学知识，涵盖CSP-J1、CSP-S1两种级别的数学问题。...
NOIP普及组2010-2017复赛试题及官方数据
06-10
NOIP普及组2010-2017复赛试题及官方数据
[毕业设计]VB+ACCESS高校班级日常管理系统(源代码+论文).zip
08-07
[毕业设计]VB+ACCESS高校班级日常管理系统(源代码+论文)
基于Misty1算法的加密软件(JAVA)的实现模块项目(源代码+论文).zip
08-07
JAVA; 毕业设计；MVC模式; JSP; SQL Server 2000 数据库管理系统; J2EE
py源码实例自动办公用Python在Excel中查找并替换数据
最新发布
08-07
python，py源码实例自动办公用Python在Excel中查找并替换数据
Rust语言的环境搭建
08-07
Rust语言的环境搭建，安装最新版的 Rust 编译工具和 Visual Studio Code。
NOIP树链剖分详解与实现
"NOIP树链剖分是用于优化树形结构数据的处理效率的一种算法，常用于解决涉及树路径信息维护的问题。该算法的主要目标是将一棵树划分为若干条链，每条链的数据结构可以高效地进行操作，使得在树上进行查询或更新操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值