[树链剖分]JZOJ 5914 盟主的忧虑

Description

江湖由 N 个门派(2≤N≤100,000,编号从 1 到 N)组成,这些门派之间有 N-1 条小道将他们连接起来,每条道路都以“尺”为单位去计量,武林盟主发现任何两个门派都能够直接或者间接通过小道连接。
    虽然整个江湖是可以互相到达的,但是他担心有心怀不轨之徒破坏这个武林的安定,破坏小道,于是武林盟主又秘密地修建了 M 条密道(1≤M≤100,000),但每条小道距离都不超过10亿尺。
    果不其然,最近一个名叫“太吾”的组织意欲破坏武林的小道,请你帮盟主想想办法,如果门派 A 到门派 B 的直连小道被破坏,从 A 走到 B 的所有路径中,经过密道的距离最少是多少?

Input

第一行数字 N M
接下来 N-1 行,每行两个整数 A B,表示 A-B 间有一条直连小道
接下来 M 行,每行三个数字 A B V,表示 A-B 间有一条代价为 V 的密道

Output

输出 N-1 行,对应原输入的小道,每个小道被破坏后,最少需要经过多长的密道?如果不存在替换的道路,请输出-1

Sample Input

6 3
4 1
1 3
4 5
1 2
6 5
3 6 8
2 3 7
6 4 5

Sample Output

8
7
5
7
5

Data Constraint

30%数据:N<=300,M<=1000
50%数据:N<=1000,M<=1000
70%数据:N<=5000,M<=5000
对于另外15%的数据点:树是一条链
100%数据:N,M<=100,000

分析

这题显然密道会密道两端到LCA中经过的边的值

这不就是树链剖分嘛

写个区间修改走人

什么?并查集做法?不会

#include <iostream>
#include <cstdio>
#include <cstring>
#define rep(i,a,b) for (i=a;i<=b;i++)
using namespace std;
const int N=1e5+10;
struct Node {
    int sz,f,s,seg,top,dep;
}a[N];
int scnt,rev[N];
struct Edge {
    int u,v,nx;
}g[2*N];
int cnt,list[N];
int t[4*N],lz[4*N];
int mn;
int n,m;

void Add(int u,int v) {g[++cnt].u=u;g[cnt].v=v;g[cnt].nx=list[u];list[u]=cnt;}

void Dfs1(int x,int f) {
    a[x].f=f;a[x].dep=a[f].dep+1;a[x].sz=1;
    for (int i=list[x];i;i=g[i].nx)
    if (g[i].v!=f) {
       Dfs1(g[i].v,x);
       a[x].sz+=a[g[i].v].sz;
        if (a[g[i].v].sz>a[a[x].s].sz) a[x].s=g[i].v;
    }
}

void Dfs2(int x,int f) {
    int son=a[x].s;
    if (son) {
        a[son].seg=++scnt;
        rev[scnt]=son;
        a[son].top=a[x].top;
        Dfs2(son,x);
    }
    for (int i=list[x];i;i=g[i].nx)
    if (!a[g[i].v].top) {
        a[g[i].v].seg=++scnt;
        rev[scnt]=g[i].v;
        a[g[i].v].top=g[i].v;
        Dfs2(g[i].v,x);
    }
}

void Build(int x,int l,int r) {
    if (l==r) {
        t[x]=2147483647;
        return;
    }
    int mid=l+r>>1;
    Build(x<<1,l,mid);Build((x<<1)+1,mid+1,r);
    t[x]=2147483647;
}

void Pushdown(int x) {
    if (lz[x]) {
        t[x<<1]=lz[x<<1]=min(!lz[x<<1]?2147483647:lz[x<<1],lz[x]);
        t[(x<<1)+1]=lz[(x<<1)+1]=min(!lz[(x<<1)+1]?2147483647:lz[(x<<1)+1],lz[x]);
        lz[x]=0;
    }
}

void Change_In_Segment(int x,int l,int r,int val,int ll,int rr) {
    if (ll>rr) return;
    if (l>rr||ll>r) return;
    if (ll<=l&&r<=rr) {
        t[x]=min(t[x],val);
        lz[x]=min(!lz[x]?2147483647:lz[x],val);
        return;
    }
    Pushdown(x);
    int mid=l+r>>1;
    if (mid>=ll) Change_In_Segment(x<<1,l,mid,val,ll,rr);
    if (mid<rr) Change_In_Segment((x<<1)+1,mid+1,r,val,ll,rr);
    t[x]=min(t[x<<1],t[(x<<1)+1]);
}

void Query_In_Segment(int x,int l,int r,int ll,int rr) {
    if (ll>rr) return;
    if (r<ll||l>rr) return;
    if (ll<=l&&r<=rr) {
        mn=min(mn,t[x]);
        return;
    }
    Pushdown(x);
    int mid=l+r>>1;
    if (ll<=mid) Query_In_Segment(x<<1,l,mid,ll,rr);
    if (mid+1<=rr) Query_In_Segment((x<<1)+1,mid+1,r,ll,rr);
}

void Query_In_Tree(int x,int y) {
    int fx=a[x].top,fy=a[y].top;
    while (fx!=fy) {
        if (a[fx].dep<a[fy].dep) swap(x,y),swap(fx,fy);
        Query_In_Segment(1,1,scnt,a[fx].seg,a[x].seg);
        x=a[fx].f;fx=a[x].top;
    }
    if (a[x].dep>a[y].dep) swap(x,y);
    Query_In_Segment(1,1,scnt,a[x].seg+1,a[y].seg);
}

void Change_In_Tree(int x,int y,int val) {
    int fx=a[x].top,fy=a[y].top;
    while (fx!=fy) {
        if (a[fx].dep<a[fy].dep) swap(x,y),swap(fx,fy);
        Change_In_Segment(1,1,scnt,val,a[fx].seg,a[x].seg);
        x=a[fx].f;fx=a[x].top;
    }
    if (a[x].dep>a[y].dep) swap(x,y);
    Change_In_Segment(1,1,scnt,val,a[x].seg+1,a[y].seg);
}

int main() {
    freopen("worry.in","r",stdin);
    freopen("worry.out","w",stdout);
    int i;
    char s[20];
    scanf("%d%d",&n,&m);
    rep(i,1,n-1) {
        int u,v;
        scanf("%d%d",&u,&v);
        Add(u,v);Add(v,u);
    }
    Dfs1(1,0);
    scnt=1;
    a[1].seg=a[1].top=rev[1]=1;
    Dfs2(1,0);
    Build(1,1,scnt);
    for (int i=1;i<=m;i++) {
        int x,y,w;
        scanf("%d%d%d",&x,&y,&w);
        Change_In_Tree(x,y,w);
    }
    for (int i=1;i<=n-1;i++) {
        mn=2147483647;
        Query_In_Tree(g[i*2-1].u,g[i*2-1].v);
        printf("%d\n",mn==2147483647?-1:mn);
    }
}

原文地址:https://www.cnblogs.com/mastervan/p/9818585.html

时间: 2024-08-05 00:10:15

[树链剖分]JZOJ 5914 盟主的忧虑的相关文章

BZOJ 2243: [SDOI2011]染色 树链剖分

2243: [SDOI2011]染色 Time Limit: 20 Sec  Memory Limit: 512 MBSubmit: 1886  Solved: 752[Submit][Status] Description 给定一棵有n个节点的无根树和m个操作,操作有2类: 1.将节点a到节点b路径上所有点都染成颜色c: 2.询问节点a到节点b路径上的颜色段数量(连续相同颜色被认为是同一段),如“112221”由3段组成:“11”.“222”和“1”. 请你写一个程序依次完成这m个操作. In

bzoj 2243: [SDOI2011]染色 线段树区间合并+树链剖分

2243: [SDOI2011]染色 Time Limit: 20 Sec  Memory Limit: 512 MBSubmit: 7925  Solved: 2975[Submit][Status][Discuss] Description 给定一棵有n个节点的无根树和m个操作,操作有2类: 1.将节点a到节点b路径上所有点都染成颜色c: 2.询问节点a到节点b路径上的颜色段数量(连续相同颜色被认为是同一段),如“112221”由3段组成:“11”.“222”和“1”. 请你写一个程序依次完

bzoj3694: 最短路(树链剖分/并查集)

bzoj1576的帮我们跑好最短路版本23333(双倍经验!嘿嘿嘿 这题可以用树链剖分或并查集写.树链剖分非常显然,并查集的写法比较妙,涨了个姿势,原来并查集的路径压缩还能这么用... 首先对于不在最短路径树上的边x->y,设t为最短路径树上lca(x,y),则t到y上的路径上的点i到根的距离都可以用h[x]+dis[x][y]+h[y]-h[i](h[]为深度)来更新,因为h[i]一定,只要让h[x]+dis[x][y]+h[y]最小就行,这里用树剖直接修改整条链上的数,就可以过了. 并查集的

洛谷 P3384 【模板】树链剖分

题目描述 如题,已知一棵包含N个结点的树(连通且无环),每个节点上包含一个数值,需要支持以下操作: 操作1: 格式: 1 x y z 表示将树从x到y结点最短路径上所有节点的值都加上z 操作2: 格式: 2 x y 表示求树从x到y结点最短路径上所有节点的值之和 操作3: 格式: 3 x z 表示将以x为根节点的子树内所有节点值都加上z 操作4: 格式: 4 x 表示求以x为根节点的子树内所有节点值之和 输入输出格式 输入格式: 第一行包含4个正整数N.M.R.P,分别表示树的结点个数.操作个数

bzoj1036 树的统计(树链剖分+线段树)

1036: [ZJOI2008]树的统计Count Time Limit: 10 Sec  Memory Limit: 162 MBSubmit: 15120  Solved: 6141[Submit][Status][Discuss] Description 一棵树上有n个节点,编号分别为1到n,每个节点都有一个权值w.我们将以下面的形式来要求你对这棵树完成一些操作: I. CHANGE u t : 把结点u的权值改为t II. QMAX u v: 询问从点u到点v的路径上的节点的最大权值 I

SPOJ QTREE Query on a tree ——树链剖分 线段树

[题目分析] 垃圾vjudge又挂了. 树链剖分裸题. 垃圾spoj,交了好几次,基本没改动却过了. [代码](自带常数,是别人的2倍左右) #include <cstdio> #include <cstring> #include <iostream> #include <algorithm> using namespace std; #define maxn 20005 int T,n,fr[maxn],h[maxn],to[maxn],ne[maxn]

树链剖分简(单)介(绍)

树链剖分可以算是一种数据结构(一大堆数组,按照这个意思,主席树就是一大堆线段树).将一棵树分割成许多条连续的树链,方便完成一下问题: 单点修改(dfs序可以完成) 求LCA(各种乱搞也可以) 树链修改(修改任意树上两点之间的唯一路径) 树链查询 (各种操作)  前两个内容可以用其他方式解决,但是下面两种操作倍增.st表,dfs序就很难解决(解决当然可以解决,只是耗时长点而已).下面开始步入正题. 树链剖分的主要目的是分割树,使它成一条链,然后交给其他数据结构(如线段树,Splay)来进行维护.常

bzoj1146整体二分+树链剖分+树状数组

其实也没啥好说的 用树状数组可以O(logn)的查询 套一层整体二分就可以做到O(nlngn) 最后用树链剖分让序列上树 1 #include<cstdio> 2 #include<cstring> 3 #include<iostream> 4 #include<algorithm> 5 using namespace std; 6 inline int read() 7 { 8 int x=0,f=1,ch=getchar(); 9 while(ch<

BZOJ 1036: [ZJOI2008]树的统计Count [树链剖分]

1036: [ZJOI2008]树的统计Count Time Limit: 10 Sec  Memory Limit: 162 MBSubmit: 14302  Solved: 5779[Submit][Status][Discuss] Description 一棵树上有n个节点,编号分别为1到n,每个节点都有一个权值w.我们将以下面的形式来要求你对这棵树完成一些操作: I. CHANGE u t : 把结点u的权值改为t II. QMAX u v: 询问从点u到点v的路径上的节点的最大权值 I