树链剖分+线段树 HDOJ 4897 Little Devil I(小恶魔)

题目链接

题意:

  给定一棵树,每条边有黑白两种颜色,初始都是白色,现在有三种操作:

    1 u v:u到v路径(最短)上的边都取成相反的颜色

    2 u v:u到v路径上相邻的边都取成相反的颜色(相邻即仅有一个节点在路径上)

    3 u v:查询u到v路径上有多少个黑色边

思路:

  对树进行树链剖分,分成重链和轻链,用两棵线段树W,L来维护。W维护树上在重链上的u和v之间的边的翻转情况(操作在线段树上的[pos[v],pos[u]]区间);L维护树上在重链上的u和v之间的相邻边的翻转情况。那么某一个点u与它父亲节点fa[u]的边的最终翻转情况为:W(pos[u], pos[u])(如果边是重链上的边),W(pos[u], pos[u])^L(pos[fa[u]], pos[fa[u]])(如果边是轻链)。对于1操作,只要简单的在W上维护就可以了。对于2操作,除了在L上操作,还要注意头和尾的特殊处理(因为对于重链内的点,不包括头尾,只在W上查询),也就是u的重链上的儿子son[u]以及u的链头p=belong[u]要在W上翻转一次,结合图可能更能理解。还有就是线段树的操作了。

另外:

  u可能没有son[u],默认为虚点0,那么在线段树上需要加上一句话:if (l == r) return ;

#include <bits/stdc++.h>

const int N = 1e5 + 5;

//线段树
#define lson l, mid, o << 1
#define rson mid + 1, r, o << 1 | 1
struct Seg_Tree {
    int fp[N<<2], s[N<<2];
    void flip(int l, int r, int o) {
        s[o] = (r - l + 1) - s[o];
        fp[o] ^= 1;
    }
    void push_up(int o) {
        s[o] = s[o<<1] + s[o<<1|1];
    }
    void push_down(int l, int r, int o) {
        if (fp[o]) {
            int mid = l + r >> 1;
            flip (lson);
            flip (rson);
            fp[o] = 0;
        }
    }
    void build(int l, int r, int o) {
        fp[o] = s[o] = 0;
        if (l == r) {
            return ;
        }
        int mid = l + r >> 1;
        build (lson);
        build (rson);
    }
    void updata(int ql, int qr, int l, int r, int o) {
        if (ql <= l && r <= qr) {
            flip (l, r, o);
            return ;
        }
        if (l == r) return ;  //!
        push_down (l, r, o);
        int mid = l + r >> 1;
        if (ql <= mid) updata (ql, qr, lson);
        if (qr > mid) updata (ql, qr, rson);
        push_up (o);
    }
    int query(int ql, int qr, int l, int r, int o) {
        if (ql <= l && r <= qr) {
            return s[o];
        }
        push_down (l, r, o);
        int mid = l + r >> 1, ret = 0;
        if (ql <= mid) ret += query (ql, qr, lson);
        if (qr > mid) ret += query (ql, qr, rson);
        push_up (o);
        return ret;
    }
}W, L;

std::vector<int> edge[N];
int sz[N], dep[N], son[N], fa[N];
int pos[N], belong[N];
int loc;
int n;

int query(int u, int v) {
    int p = belong[u], q = belong[v], ret = 0;
    while (p != q) {
        if (dep[p] < dep[q]) {
            std::swap (p, q);
            std::swap (u, v);
        }
        if (u != p) {
            ret += W.query (pos[son[p]], pos[u], 1, n, 1);
        }
        ret += (W.query (pos[p], pos[p], 1, n, 1) ^ L.query (pos[fa[p]], pos[fa[p]], 1, n, 1));
        u = fa[p];
        p = belong[u];
    }

    if (u == v) return ret;

    if (dep[u] < dep[v]) {
        std::swap (u, v);
    }
    ret += W.query (pos[son[v]], pos[u], 1, n, 1);
    return ret;
}

void modify(int t, int u, int v) {
    int p = belong[u], q = belong[v];
    while (p != q) {
        if (dep[p] < dep[q]) {
            std::swap (p, q);
            std::swap (u, v);
        }
        if (t == 1) {
            W.updata (pos[p], pos[u], 1, n, 1);
        } else {
            L.updata (pos[p], pos[u], 1, n, 1);
            W.updata (pos[son[u]], pos[son[u]], 1, n, 1);
            W.updata (pos[p], pos[p], 1, n, 1);
        }
        u = fa[p];
        p = belong[u];
    }

    if (dep[u] < dep[v]) {
        std::swap (u, v);
    }
    if (t == 1) {
        if (u == v) return ;
        W.updata (pos[son[v]], pos[u], 1, n, 1);
    } else {
        L.updata (pos[v], pos[u], 1, n, 1);
        W.updata (pos[son[u]], pos[son[u]], 1, n, 1);
        W.updata (pos[v], pos[v], 1, n, 1);
    }
}

//树链剖分
void DFS2(int u, int chain) {
    pos[u] = ++loc;
    belong[u] = chain;
    if (son[u]) {
        DFS2 (son[u], chain);
    }
    for (auto v: edge[u]) {
        if (v == fa[u] || v == son[u]) continue;
        DFS2 (v, v);
    }
}

void DFS1(int u, int pa) {
    sz[u] = 1; dep[u] = dep[pa] + 1;
    son[u] = 0; fa[u] = pa;
    for (auto v: edge[u]) {
        if (v == pa) continue;
        DFS1 (v, u);
        sz[u] += sz[v];
        if (sz[son[u]] < sz[v]) son[u] = v;
    }
}

void prepare() {
    sz[0] = dep[0] = fa[0] = 0;
    DFS1 (1, 0);
    loc = 0;
    DFS2 (1, 1);
    W.build (1, n, 1);
    L.build (1, n, 1);
}

void init_edge(int n) {
    for (int i=1; i<=n; ++i) {
        edge[i].clear ();
    }
}

int main() {
    int T;
    scanf ("%d", &T);
    while (T--) {
        scanf ("%d", &n);

        init_edge (n);
        for (int i=1; i<n; ++i) {
            int u, v;
            scanf ("%d%d", &u, &v);
            edge[u].push_back (v);
            edge[v].push_back (u);
        }

        prepare ();

        int q;
        scanf ("%d", &q);
        while (q--) {
            int t, u, v;
            scanf ("%d%d%d", &t, &u, &v);
            if (t == 3) {
                printf ("%d\n", query (u, v));
            } else {
                modify (t, u, v);
            }
        }
    }
    return 0;
}

  

时间: 2024-10-27 19:03:41

树链剖分+线段树 HDOJ 4897 Little Devil I(小恶魔)的相关文章

Aizu 2450 Do use segment tree 树链剖分+线段树

Do use segment tree Time Limit: 1 Sec Memory Limit: 256 MB 题目连接 http://www.bnuoj.com/v3/problem_show.php?pid=39566 Description Given a tree with n (1 ≤ n ≤ 200,000) nodes and a list of q (1 ≤ q ≤ 100,000) queries, process the queries in order and out

Hdu 3966 Aragorn&#39;s Story (树链剖分 + 线段树区间更新)

题目链接: Hdu 3966 Aragorn's Story 题目描述: 给出一个树,每个节点都有一个权值,有三种操作: 1:( I, i, j, x ) 从i到j的路径上经过的节点全部都加上x: 2:( D, i, j, x ) 从i到j的路径上经过的节点全部都减去x: 3:(Q, x) 查询节点x的权值为多少? 解题思路: 可以用树链剖分对节点进行hash,然后用线段树维护(修改,查询),数据范围比较大,要对线段树进行区间更新 1 #include <cstdio> 2 #include

【bzoj3589】动态树 树链剖分+线段树

题目描述 别忘了这是一棵动态树, 每时每刻都是动态的. 小明要求你在这棵树上维护两种事件 事件0:这棵树长出了一些果子, 即某个子树中的每个节点都会长出K个果子. 事件1:小明希望你求出几条树枝上的果子数. 一条树枝其实就是一个从某个节点到根的路径的一段. 每次小明会选定一些树枝, 让你求出在这些树枝上的节点的果子数的和. 注意, 树枝之间可能会重合, 这时重合的部分的节点的果子只要算一次. 输入 第一行一个整数n(1<=n<=200,000), 即节点数. 接下来n-1行, 每行两个数字u,

BZOJ2243 (树链剖分+线段树)

Problem 染色(BZOJ2243) 题目大意 给定一颗树,每个节点上有一种颜色. 要求支持两种操作: 操作1:将a->b上所有点染成一种颜色. 操作2:询问a->b上的颜色段数量. 解题分析 树链剖分+线段树. 开一个记录类型,记录某一段区间的信息.l 表示区间最左侧的颜色 , r 表示区间最右侧的颜色 , sum 表示区间中颜色段数量. 合并时判断一下左区间的右端点和有区间的左端点的颜色是否一样. 树上合并时需要用两个变量ans1,ans2来存储.ans1表示x往上走时形成的链的信息,

bzoj4304 (树链剖分+线段树)

Problem T2 (bzoj4304 HAOI2015) 题目大意 给定一颗树,1为根节点,要求支持三种操作. 操作 1 :把某个节点 x 的点权增加 a . 操作 2 :把某个节点 x 为根的子树中所有点的点权都增加 a . 操作 3 :询问某个节点 x 到根的路径中所有点的点权和. 解题分析 练手题.树链剖分+线段树. 参考程序 1 #include <cstdio> 2 #include <cstring> 3 #include <cmath> 4 #incl

【BZOJ】1146: [CTSC2008]网络管理Network(树链剖分+线段树套平衡树+二分 / dfs序+树状数组+主席树)

第一种做法(时间太感人): 这题我真的逗了,调了一下午,疯狂造数据,始终找不到错. 后来发现自己sb了,更新那里没有打id,直接套上u了.我.... 调了一下午啊!一下午的时光啊!本来说好中午A掉去学习第二种做法,噗 好吧,现在第一种做法是hld+seg+bst+二分,常数巨大,log^4级别,目前只会这种. 树剖后仍然用线段树维护dfs序区间,然后在每个区间建一颗平衡树,我用treap,(这题找最大啊,,,囧,并且要注意,这里的rank是比他大的数量,so,我们在二分时判断要判断一个范围,即要

【bzoj4811】[Ynoi2017]由乃的OJ 树链剖分+线段树区间合并

题目描述 由乃正在做她的OJ.现在她在处理OJ上的用户排名问题.OJ上注册了n个用户,编号为1-",一开始他们按照编号 排名.由乃会按照心情对这些用户做以下四种操作,修改用户的排名和编号:然而由乃心情非常不好,因为Deus天 天问她题...因为Deus天天问由乃OI题,所以由乃去学习了一下OI,由于由乃智商挺高,所以OI学的特别熟练她 在RBOI2016中以第一名的成绩进入省队,参加了NOI2016获得了金牌保送 Deus:这个题怎么做呀? yuno:这个不是NOI2014的水题吗... Deu

HDU 2460 Network(双连通+树链剖分+线段树)

HDU 2460 Network 题目链接 题意:给定一个无向图,问每次增加一条边,问个图中还剩多少桥 思路:先双连通缩点,然后形成一棵树,每次增加一条边,相当于询问这两点路径上有多少条边,这个用树链剖分+线段树处理 代码: #include <cstdio> #include <cstring> #include <algorithm> #include <vector> using namespace std; #pragma comment(linke

【bzoj1959】[Ahoi2005]LANE 航线规划 离线处理+树链剖分+线段树

题目描述 对Samuel星球的探险已经取得了非常巨大的成就,于是科学家们将目光投向了Samuel星球所在的星系——一个巨大的由千百万星球构成的Samuel星系. 星际空间站的Samuel II巨型计算机经过长期探测,已经锁定了Samuel星系中许多星球的空间坐标,并对这些星球从1开始编号1.2.3……. 一些先遣飞船已经出发,在星球之间开辟探险航线. 探险航线是双向的,例如从1号星球到3号星球开辟探险航线,那么从3号星球到1号星球也可以使用这条航线. 例如下图所示: 在5个星球之间,有5条探险航

HDU4897 (树链剖分+线段树)

Problem Little Devil I (HDU4897) 题目大意 给定一棵树,每条边的颜色为黑或白,起始时均为白. 支持3种操作: 操作1:将a->b的路径中的所有边的颜色翻转. 操作2:将所有 有且仅有一个点在a->b的路径中 的边的颜色翻转. 操作3:询问a->b的路径中的黑色边数量. 解题分析 考虑操作1,只需正常的树链剖分+线段树维护即可.用线段树维护每条边,tag_1[i]表示该区间中的黑色边数量. 考虑操作2,一个节点相邻的边只可能为重链和轻链,且重链的数目小于等于