首页 > 其他分享 >P3038 [USACO11DEC] Grass Planting G - 重链剖分

P3038 [USACO11DEC] Grass Planting G - 重链剖分

时间:2024-02-17 20:55:39浏览次数:19  
标签:Planting sx 剖分 int top son dep 重链 id

本题可以说是板题 P3384 的弱化版,只不过要改的变成了边权

边权很好处理,只需要将每个边的边权下放到两端点深度比较深的上面就好了(因为每个点连比它浅的节点必定只有一条边)。

那么就将模板改一下就好了

代码如下:

#include <cstdio>
using namespace std;
const int N = 1e5 + 5;
int n, m;
int head[N], e_cnt;
int siz[N], son[N], fa[N], dep[N], id[N], cnt, top[N];
struct edge {
    int to, nxt;
}e[N << 1];
void swap(int &a, int &b) {
    a ^= b;
    b ^= a;
    a ^= b;
    return ;
}
void add(int u, int v) {
    e[++ e_cnt] = (edge){v, head[u]};
    head[u] = e_cnt;
}
void dfs1(int sx, int ffa) {
    fa[sx] = ffa;
    dep[sx] = dep[ffa] + 1;
    siz[sx] = 1;
    int maxn = -1;
    for (int i = head[sx];i;i = e[i].nxt) {
        if (e[i].to == ffa) continue;
        dfs1 (e[i].to, sx);
        siz[sx] += siz[e[i].to];
        if (siz[e[i].to] > maxn) {
            maxn = e[i].to;
            son[sx] = e[i].to;
        }
    }
    return ;
}
void dfs2(int sx, int topf) {
    id[sx] = ++ cnt;
    top[sx] = topf;
    if (son[sx] != 0)
        dfs2 (son[sx], topf);
    for (int i = head[sx];i;i = e[i].nxt) {
        if (e[i].to == fa[sx] || e[i].to == son[sx]) continue;
        dfs2 (e[i].to, e[i].to);
    }
    return ;
}
struct sgt {
    int sum[N << 2], lz[N << 2];
    void PushUp(int u) {
        sum[u] = sum[u << 1] + sum[u << 1 | 1];
        return ;
    }
    void PushDown(int u, int s) {
        if (lz[u]) {
            sum[u << 1] += lz[u] * (s - (s >> 1));
            sum[u << 1 | 1] += lz[u] * (s >> 1);
            lz[u << 1] += lz[u];
            lz[u << 1 | 1] += lz[u];
            lz[u] = 0;
        }
        return ;
    }
    void build(int u, int l, int r) {
        if (l == r) {
            sum[u] = 0;
            return ;
        }
        int mid = l + r >> 1;
        build (u << 1, l, mid);
        build (u << 1 | 1, mid + 1, r);
        PushUp (u);
    }
    void modify(int u, int l, int r, int L, int R, int k) {
        if (L <= l && r <= R) {
            sum[u] += (r - l + 1) * k;
            lz[u] += k;
            return ;
        }
        PushDown (u, r - l + 1);
        int mid = l + r >> 1;
        if (L <= mid)
            modify (u << 1, l, mid, L, R, k);
        if (mid < R)
            modify (u << 1 | 1, mid + 1, r, L, R, k);
        PushUp (u);
        return ;
    }
    void change(int x, int y) {
        while (top[x] != top[y]) {
            if (dep[top[x]] > dep[top[y]])
                swap (x, y);
            modify (1, 1, n, id[top[y]], id[y], 1);
            y = fa[top[y]];
        }
        if (dep[x] > dep[y])
            swap (x, y);
        modify (1, 1, n, id[x] + 1, id[y], 1);
        return ;
    }
    int query(int u, int l, int r, int L, int R) {
        if (L <= l && r <= R)
            return sum[u];
        int ans = 0, mid = l + r >> 1;
        PushDown (u, r - l + 1);
        if (L <= mid)
            ans += query (u << 1, l, mid, L, R);
        if (mid < R)
            ans += query (u << 1 | 1, mid + 1, r, L, R);
        return ans;
    }
}tre;
int main() {
    scanf ("%d%d", &n, &m);
    for (int i = 1;i < n; ++ i) {
        int u, v;
        scanf ("%d%d", &u, &v);
        add(u, v), add(v, u);
    }
    dfs1(1, 1);
    dfs2(1, 1);
    tre.build(1, 1, n);
    while (m --) {
        char opt;
        scanf (" %c", &opt);
        if (opt == 'P') {
            int x, y;
            scanf ("%d%d", &x, &y);
            tre.change (x, y);
        }
        if (opt == 'Q') {
            int x, y;
            scanf ("%d%d", &x, &y);
            if (dep[x] > dep[y])
                printf ("%d\n", tre.query(1, 1, n, id[x], id[x]));
            else printf ("%d\n", tre.query(1, 1, n, id[y], id[y]));
        }
    }
    return 0;
}

轻松 A 掉了这道题目,但是线段树这么长,码着也怪累的,而且还不好调,再看题目我们惊奇地发现每次 Q 操作只找一条边,下放后就相当于只查询单点,那么区间修改,单点查询就可以用树状数组来替代线段树,所以就有了二代代码

#include <cstdio>
#define lowbit(x) (x) & (-x)
using namespace std;
const int N = 1e5 + 5;
int head[N], e_cnt;
int n, m;
int fa[N], siz[N], son[N], dep[N];
int id[N], cnt, top[N];
struct edge {
    int nxt, to;
}e[N << 1];
void add(int u, int v) {
    e[++e_cnt] = (edge){head[u], v};
    head[u] = e_cnt;
}
void swap(int &a, int &b) {
    a ^= b;
    b ^= a;
    a ^= b;
}
void dfs1(int sx, int ffa) {
    fa[sx] = ffa;
    siz[sx] = 1;
    dep[sx] = dep[ffa] + 1;
    int maxn = -1;
    for (int i = head[sx];i;i = e[i].nxt) {
        if (e[i].to == ffa) continue;
        dfs1 (e[i].to, sx);
        if (siz[e[i].to] > maxn) {
            maxn = siz[e[i].to];
            son[sx] = e[i].to;
        }
        siz[sx] += siz[e[i].to];
    }
    return ;
}
void dfs2(int sx, int topf) {
    top[sx] = topf;
    id[sx] = ++ cnt;
    if (son[sx]) dfs2 (son[sx], topf);
    for (int i = head[sx];i;i = e[i].nxt) {
        if (e[i].to == fa[sx] || e[i].to == son[sx]) continue;
        dfs2 (e[i].to, e[i].to);
    }
    return ;
}
int tre[N];
void modify(int x, int k) {
    for (;x <= n;x += lowbit(x))
        tre[x] += k;
    return ;
}
int query(int x) {
    int ans = 0;
    for (;x > 0;x -= lowbit(x))
        ans += tre[x];
    return ans;
}
void change(int u, int v) {
    while (top[u] != top[v]) {
        if (dep[top[u]] > dep[top[v]]) swap (u, v);
        modify (id[top[v]], 1);
        modify (id[v] + 1, -1);
        v = fa[top[v]];
    }
    if (dep[u] > dep[v]) swap (u, v);
    modify (id[u] + 1, 1);
    modify (id[v] + 1, -1);
    return ;
}
int main() {
    scanf ("%d%d", &n, &m);
    for (int i = 1;i < n; ++ i) {
        int u, v;
        scanf ("%d%d", &u, &v);
        add(u, v), add(v, u);
    }
    dfs1 (1, 1);
    dfs2 (1, 1);
    while (m --) {
        char opt;
        scanf (" %c", &opt);
        if (opt == 'P') {
            int u, v;
            scanf ("%d%d", &u, &v);
            change (u, v);
        }
        else if (opt == 'Q') {
            int u, v;
            scanf ("%d%d", &u, &v);
            if (dep[u] > dep[v])
                printf ("%d\n", query (id[u]));
            else printf ("%d\n", query (id[v]));
        }
    }
    return 0;
}

标签:Planting,sx,剖分,int,top,son,dep,重链,id
From: https://www.cnblogs.com/Assassins-Creed/p/18018379

相关文章

  • 树链剖分
    树链剖分分为重链剖分和长链剖分重链剖分首先是重链剖分,树链剖分顾名思义是一种将代码大小增加1k树剖成一条条链的方法。定义:重儿子该节点所有儿子中以该儿子为根的子树最大的儿子重边连接该节点与该节点的重儿子的那条边重链由根节点或一个轻儿子为链头一路重边连到叶......
  • 树链剖分
    看逆天算法,品百味OI#41.重链剖分给出如下定义:重子结点:一个点的子节点中子树最大的点轻子节点:剩余的子节点重边:该节点到重子节点的边轻边:到轻子节点的边重链:若干条首尾相接的重边预处理由两个DFS实现DFS1:记录节点的父节点、深度、子树大小、重子结点DFS......
  • 重链剖分
    重链剖分优先走重儿子,路径跳不超过\(O(\logn)\)intsiz[N],fa[N],dep[N],top[N],dfn[N],hson[N],dfc;//注意每个都要处理voiddfs1(intx,intFa){ fa[x]=Fa; siz[x]=1; hson[x]=0; for(inti=h[x];i;i=e[i].ne){ inty=e[i].to; if(y==Fa)continue; dep[y]=dep[......
  • 树链剖分学习笔记
    树链剖分,计算机术语,指一种对树进行划分的算法,它先通过轻重边剖分将树分为多条链,保证每个点属于且只属于一条链,然后再通过数据结构(树状数组、BST、SPLAY、线段树等)来维护每一条链。——百度百科重链剖分概念1重儿子一个父节点的所有儿子中,子树节点最大(siz最大)的节点。记......
  • 链剖分
    重链剖分第一次DFS求重儿子(子节点更多的儿子)。第二次DFS求重链剖分(先访问重儿子再访问其他轻儿子)。变量:重儿子,子树大小,DFS序(\(x\)根子树DFS序中第一次出现位置),以\(x\)为根的子树的最后一次出现位置,深度,\(x\)所在重链的顶端。voiddfs1(intx){//求出重儿子,sz[v]......
  • 树链剖分
    son[x]表示节点\(x\)的重儿子,若为\(0\),则说明\(x\)为叶子节点id[x]表示节点\(x\)的dfs序编号f[x]表示节点\(x\)的父节点dep[x]表示节点\(x\)的深度sz[x]表示节点为\(x\)的子树的大小top[x]表示x所在重链顶部的节点函数原型voiddfs1(llu,llfa)功能:计算dep[]、f[]、sz[]和......
  • 【动态规划】长链剖分优化树形 dp
    我们在树形dp中经常会遇到这样一个模型:设\(f_{x,i}\)表示节点\(x\)的子树中深度为\(x\)的答案...有递推式:\(f_{x,i}=\sum_{son}f_{son,i-1/i+1}\dots\)。这样直接做是\(\Theta(n^2)\)的,我们考虑去优化这个dp。有一个小优化,就是我们想让\(f_x\)直接继承......
  • Planting poplar threes—the application of a Chinese way to control soil cadmium
    SituationsofsoilcadmiumpollutioninJapan Inthelastcentury,therewasaserioushealthaccidentinJapan,anoutbreakofItai-itaidisease,whichwascausedbythecadmiumpollution.   Inthe"Itai-itaiDisease"incidentinJapan,af......
  • 【树链剖分】P3401 洛谷树 题解
    P3401考虑先将路径权值进行转化,因为很难对路径直接进行统计。考虑如何表示出这条路径的权值。记\(s_i=\oplus_{j\in\text{path}(1,i)}w_j\),其中\(\text{path}(i,j)\)表示\(i\)到\(j\)的路径上的边集。则\(u\tov\)的路径的权值为\(s_u\opluss_v\)。现在转变为......
  • 重链剖分的另一个性质
    我们大家都知道树的节点深度和是比树的节点高度和要大的,这个直观感受一下就能理解。什么时候这俩东西一样呢?答案是树形态形如一条链的时候。回忆重链剖分,重链剖分的一个性质是如果说我们把所有重链缩成一个点,形成的新树上节点深度最大是\(\logn\)级别,当然用完全二叉树就能把深......