ABC133FColorful Tree

题意

给定一颗边有颜色和权值的树，多次询问，每次询问，首先更改颜色为x的边的权值为y，然后输出u到v的距离。

数据都是1e5量级的。

思路

我自己一开始用树链剖分的做法。

// #pragma GCC optimize(2)

// #pragma GCC optimize(3)

// #pragma GCC optimize(4)

#include <algorithm>

#include  <iterator>

#include  <iostream>

#include   <cstring>

#include   <cstdlib>

#include   <iomanip>

#include    <bitset>

#include    <cctype>

#include    <cstdio>

#include    <string>

#include    <vector>

#include     <stack>

#include     <cmath>

#include     <queue>

#include      <list>

#include       <map>

#include       <set>

#include   <cassert>

// #include<bits/extc++.h>

// using namespace __gnu_pbds;

using namespace std;

#define pb push_back

#define fi first

#define se second

#define debug(x) cerr<<#x << " := " << x << endl;

#define bug cerr<<"-----------------------"<<endl;

#define FOR(a, b, c) for(int a = b; a <= c; ++ a)

typedef long long ll;

typedef long double ld;

typedef pair<int, int> pii;

typedef pair<ll, ll> pll;

const int inf = 0x3f3f3f3f;

const ll inff = 0x3f3f3f3f3f3f3f3f;

const int mod = ;

template<typename T>

inline T read(T&x){

    x=;int f=;char ch=getchar();

    while (ch<''||ch>'') f|=(ch=='-'),ch=getchar();

    while (ch>=''&&ch<='') x=x*+ch-'',ch=getchar();

    return x=f?-x:x;

}

/**********showtime************/

            const int maxn = 1e5+;

            vector<int>mp[maxn];

            vector<int>col[maxn];

            vector<int>wen[maxn];

            struct E{

                int u, v, c, d;

                void init(int U, int V, int C, int D) {

                    u = U;

                    v = V;

                    c = C;

                    d = D;

                }

            } edge[maxn];

            int dp[maxn], son[maxn], sz[maxn], pa[maxn];

            void dfs1(int u, int fa) {

                sz[u] = ;

                pa[u] = fa;

                dp[u] = dp[fa] + ;

                int mx = ;

                for(int v : mp[u]) {

                    if(v == fa) continue;

                    dfs1(v, u);

                    sz[u] += sz[v];

                    if(mx < sz[v]) mx = sz[v], son[u] = v;

                }

            }

            int id[maxn], top[maxn], tot;

            void dfs2(int u, int fa, int tp) {

                top[u] = tp;

                id[u] = ++tot;

                if(son[u]) dfs2(son[u], u, tp);

                for(int v : mp[u]) {

                    if(v == fa || v == son[u]) continue;

                    dfs2(v, u, v);

                }

            }

            ll ans[maxn];

            ll sum[maxn<<];

            void update(int pos, int val, int le, int ri, int rt) {

                if(le == ri) {

                    sum[rt] = val;

                    return;

                }

                int mid = (le + ri) >> ;

                if(pos <= mid) update(pos, val, le, mid, rt<<);

                else update(pos, val, mid+, ri, rt<<|);

                sum[rt] = sum[rt<<] + sum[rt<<|];

            }

            ll query(int L, int R, int le, int ri, int rt) {

                if(le >= L && ri <= R) {

                    return sum[rt];

                }

                ll res = ;

                int mid = (le + ri) >> ;

                if(mid >= L) res += query(L, R, le, mid, rt<<);

                if(mid < R) res += query(L, R, mid+, ri, rt<<|);

                return res;

            }

            int n,m;

            ll solve(int u, int v) {

                ll res = ;

                while(top[u] != top[v]) {

                    if(dp[top[u]] > dp[top[v]]) {

                        res += query(id[top[u]] , id[u], , n, );

                        u = pa[top[u]];

                    }

                    else {

                        res += query(id[top[v]], id[v], , n, );

                        v = pa[top[v]];

                    }

                }

                if(u != v) {

                    if(id[u] < id[v]) res += query(id[u]+, id[v],, n, );

                    else res += query(id[v]+, id[u], , n, );

                }

                return res;

            }

            struct Q{

                int x, y;

                int u,v;

            }q[maxn];

int main(){

            scanf("%d%d", &n, &m);

            for(int i=; i<n; i++) {

                int u, v, c, d;

                scanf("%d%d%d%d", &u, &v, &c, &d);

                edge[i].init(u, v, c, d);

                mp[u].pb(v);

                mp[v].pb(u);

                col[c].pb(i);

            }

            dfs1(, );

            dfs2(, , );

            for(int i=; i<=m; i++) {

                scanf("%d%d%d%d", &q[i].x, &q[i].y, &q[i].u, &q[i].v);

                wen[q[i].x].pb(i);

            }

            for(int i=; i<=n; i++) {

                if(wen[i].size() ==  || col[i].size() == ) continue;

                /// count

                for(int dd : col[i]) {

                    int u = edge[dd].u;

                    int v = edge[dd].v;

                    if(dp[u] < dp[v]) swap(u, v);

                    update(id[u], , , n, );

                }

                for(int dd: wen[i]) {

                    ans[dd] += solve(q[dd].u, q[dd].v) * q[dd].y;

                }

                for(int dd : col[i]) {

                    int u = edge[dd].u;

                    int v = edge[dd].v;

                    if(dp[u] < dp[v]) swap(u, v);

                    update(id[u], , , n, );

                }

                ///sum

                for(int dd : col[i]) {

                    int u = edge[dd].u;

                    int v = edge[dd].v;

                    if(dp[u] < dp[v]) swap(u, v);

                    update(id[u], edge[dd].d, , n, );

                }

                for(int dd: wen[i]) {

                    ans[dd] -= solve(q[dd].u, q[dd].v);

                }

                for(int dd : col[i]) {

                    int u = edge[dd].u;

                    int v = edge[dd].v;

                    if(dp[u] < dp[v]) swap(u, v);

                    update(id[u], , , n, );

                }

            }

            for(int i=; i<n; i++) {

                int u = edge[i].u;

                int v = edge[i].v;

                if(dp[u] < dp[v]) swap(u, v);

                update(id[u], edge[i].d, , n, );

            }

            for(int i=; i<=m; i++) {

                int u = q[i].u;

                int v = q[i].v;

                ans[i] += solve(u, v);

            }

            for(int i=; i<=m; i++) printf("%lld\n", ans[i]);

            return ;

}

还有树上莫队和树上差分的思路。

正在搞树上莫队的方法。搞好了。

// #pragma GCC optimize(2)

// #pragma GCC optimize(3)

// #pragma GCC optimize(4)

#include <algorithm>

#include  <iterator>

#include  <iostream>

#include   <cstring>

#include   <cstdlib>

#include   <iomanip>

#include    <bitset>

#include    <cctype>

#include    <cstdio>

#include    <string>

#include    <vector>

#include     <stack>

#include     <cmath>

#include     <queue>

#include      <list>

#include       <map>

#include       <set>

#include   <cassert>

// #include<bits/extc++.h>

// using namespace __gnu_pbds;

using namespace std;

#define pb push_back

#define fi first

#define se second

#define debug(x) cerr<<#x << " := " << x << endl;

#define bug cerr<<"-----------------------"<<endl;

#define FOR(a, b, c) for(int a = b; a <= c; ++ a)

typedef long long ll;

typedef long double ld;

typedef pair<int, int> pii;

typedef pair<ll, ll> pll;

const int inf = 0x3f3f3f3f;

const ll inff = 0x3f3f3f3f3f3f3f3f;

const int mod = ;

template<typename T>

inline T read(T&x){

    x=;int f=;char ch=getchar();

    while (ch<''||ch>'') f|=(ch=='-'),ch=getchar();

    while (ch>=''&&ch<='') x=x*+ch-'',ch=getchar();

    return x=f?-x:x;

}

/**********showtime************/

            const int maxn = 1e5+;

            vector<int>mp[maxn];

            struct E {

                int u,v;

                int c,d;

                void init(int U, int V ,int C, int D) {

                    u = U;  v = V; c = C; d = D;

                }

            } edge[maxn];

            int dp[maxn];

            int st[maxn ],ed[maxn], tim = ;

            int fa[maxn][];

            int a[maxn*];

            void dfs(int u, int o) {

                dp[u] = dp[o] + ;

                st[u] = ++tim;

                a[tim] = u;

                fa[u][] = o;

                for(int i=; i<; i++)

                    fa[u][i] = fa[fa[u][i-]][i-];

                for(int v : mp[u]) {

                    if(v == o) continue;

                    dfs(v, u);

                }

                ed[u] = ++tim;

                a[tim] = u;

            }

            int lca(int u, int v) {

                if(dp[u] < dp[v]) swap(u, v);

                for(int i=; i>=; i--) {

                    if(dp[fa[u][i]] >= dp[v])

                        u = fa[u][i];

                }

                if(u == v) return u;

                for(int i=; i>=; i--) {

                    if(fa[u][i] != fa[v][i])

                        u = fa[u][i], v = fa[v][i];

                }

                return fa[u][];

            }

            int c[maxn], d[maxn];

            struct Q{

//                int u, v;

                int le, ri;

                int lb;

                int x, y;

                int id;

            } qry[maxn];

            bool cmp(Q a, Q b) {

                if(a.lb != b.lb)

                    return a.lb < b.lb;

                return a.ri < b.ri;

            }

            int ans[maxn];

            int sum,colcnt[maxn],colsum[maxn],pot[maxn];

            void add(int id) {

                if(pot[a[id]] == ) pot[a[id]] = ;

                else pot[a[id]] = ;

                int col = c[a[id]];

                if(pot[a[id]]) {

                    colcnt[col] ++;

                    colsum[col] += d[a[id]];

                    sum += d[a[id]];

                }

                else {

                    colcnt[col] --;

                    colsum[col] -= d[a[id]];

                    sum -= d[a[id]];

                }

            }

int main(){

            int n,m;

            scanf("%d%d", &n, &m);

            int block = ;

            for(int i=; i<n; i++) {

                int u,v,c,d;

                scanf("%d%d%d%d", &u, &v, &c, &d);

                edge[i].init(u, v, c, d);

                mp[u].pb(v);

                mp[v].pb(u);

            }

            dfs(, );

            for(int i=; i<n; i++) {

                int u = edge[i].u, v = edge[i].v;

                if(dp[u] < dp[v]) swap(u, v);

                c[u] = edge[i].c;

                d[u] = edge[i].d;

            }

            for(int i=; i<=m; i++) {

                int x, y, u, v;

                scanf("%d%d%d%d", &x, &y, &u, &v);

                qry[i].id = i;

                qry[i].x = x;

                qry[i].y = y;

                if(st[u] > st[v]) swap(u, v);

                int _lca = lca(u, v);

                if(_lca == u) {

                    qry[i].le = st[u]+;

                    qry[i].ri = st[v];

                    qry[i].lb = qry[i].le / block;

                }

                else {

                    qry[i].le = ed[u];

                    qry[i].ri = st[v];

                    qry[i].lb = qry[i].le / block;

                }

            }

            sort(qry+, qry++m, cmp);

            int le = , ri = ;

            for(int i=; i<=m; i++) {

                while(le < qry[i].le) add(le), le++;

                while(le > qry[i].le) le--, add(le);

                while(ri < qry[i].ri) ri++, add(ri);

                while(ri > qry[i].ri) add(ri), ri--;

                ans[qry[i].id] = sum - colsum[qry[i].x] + colcnt[qry[i].x] * qry[i].y;

            }

            for(int i=; i<=m; i++) printf("%d\n", ans[i]);

            return ;

}

ABC133F - Colorful Tree的更多相关文章

  1. @atcoder - ABC133F@ Colorful Tree

    目录 @description@ @solution - 1@ @accepted code - 1@ @solution - 2@ @accepted code - 2@ @details@ @de ...

  2. 2017 Multi-University Training Contest - Team 1 1003&&HDU 6035 Colorful Tree【树形dp】

    Colorful Tree Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others)T ...

  3. hdu6035 Colorful Tree 树形dp 给定一棵树，每个节点有一个颜色值。定义每条路径的值为经过的节点的不同颜色数。求所有路径的值和。

    /** 题目:hdu6035 Colorful Tree 链接:http://acm.hdu.edu.cn/showproblem.php?pid=6035 题意:给定一棵树,每个节点有一个颜色值.定 ...

  4. AtCoder Beginner Contest 133 F Colorful Tree

    Colorful Tree 思路: 如果强制在线的化可以用树链剖分. 但这道题不强制在线,那么就可以将询问进行差分,最后dfs时再计算每个答案的修改值, 只要维护两个数组就可以了,分别表示根节点到当前 ...

  5. HDU 6035 - Colorful Tree | 2017 Multi-University Training Contest 1

    /* HDU 6035 - Colorful Tree [ DFS,分块 ] 题意: n个节点的树,每个节点有一种颜色(1~n),一条路径的权值是这条路上不同的颜色的数量,问所有路径(n*(n-1)/ ...

  6. [HDU6793] Tokitsukaze and Colorful Tree

    题目 又是一个条历新年,窗前的灼之花又盛开了. 时隔多年,现在只有这一棵树上盛开着残存的 \(n\) 朵灼之花了. 尽管如此,这些灼之 花仍散发出不同色彩的微弱的光芒. 灼之花的生命极为短暂,但它的花 ...

  7. Colorful tree

    cnbb 我被数组清零卡了一天.. 子树改色询问子树颜色数.. 先考虑颜色为x的节点对祖先答案的贡献,那么我们考虑把所有这些节点都搞出来,按dfs序排序,然后考虑每个节点a掌管的祖先是它和按dfs序的 ...

  8. 2017ACM暑期多校联合训练 - Team 1 1003 HDU 6035 Colorful Tree （dfs）

    题目链接 Problem Description There is a tree with n nodes, each of which has a type of color represented ...

  9. HDU-6035：Colorful Tree（虚树+DP）

    这里有三道长得像的题: 一:HDU6036: There is a tree with nn nodes, each of which has a type of color represented ...

随机推荐

  1. 【译】在 Linux 上不安装 Mono 构建 .NET Framework 类库

    在这篇文章中,我展示了如何在Linux上构建针对.NET Framework版本的.NET项目,而不使用Mono.通用使用微软新发布的 Mocrosoft.NETFramework.Reference ...

  2. 思路重要or技术重要？

    1,思路串通代码的重要性 前段时间,同事在工作上出现一点难题,在技术大佬中看起来算是微不足道的一点小事,由于没有思路,代码也无从下手,他在百度上条框上搜索自己想要的答案,却始终没有比较理想的,大部分的 ...

  3. 基于 Autojs 的 APP、小程序自动化测试 SDK

    原文:https://blog.csdn.net/laobingm/article/details/98317394 autojs sdk基于 Autojs 的 APP.小程序自动化测试 SDK,支持 ...

  4. [ PyQt入门教程 ] PyQt5基本控件使用:消息弹出、用户输入、文件对话框

    本文主要介绍PyQt界面实现中常用的消息弹出对话框.提供用户输入的输入框.打开文件获取文件/目录路径的文件对话框.学习这三种控件前,先想一下它们使用的主要场景: 1.消息弹出对话框.程序遇到问题需要退 ...

  5. php 生成随机字符串，数字，大写字母，小写字母，特殊字符可以随意组合

    * 生成随机字符串* @param int       $length  要生成的随机字符串长度* @param string    $type    随机码类型:0,数字+大小写字母:1,数字:2, ...

  6. 控制台出现_ob_:Obsever

    我遇到一个问题:我的代码想让他点击之后得到经纬度坐标数组,然后我就这样写了 然而控制台却读取出了

  7. 《HTTP权威指南》--阅读笔记（二）

    URL的三部分: 1,方案 scheme 2,服务器位置 3,资源路径 URL语法: <scheme>://<user>:<password>@<host&g ...

  8. 9、数组中删除元素（test6.java）

    前文讲到,通过函数,进行数组元素的添加,这里同样通过这个函数,进行数组的删除. 举个例子,代码如下: //导入输入所需要的包 import java.util.Scanner; public clas ...

  9. Netty学习(七)-Netty编解码技术以及ProtoBuf和Thrift的介绍

    在前几节我们学习过处理粘包和拆包的问题,用到了Netty提供的几个解码器对不同情况的问题进行处理.功能很是强大.我们有没有去想这么强大的功能是如何实现的呢?背后又用到了什么技术?这一节我们就来处理这个 ...

  10. Flink 源码解析 —— 如何获取 JobGraph？

    JobGraph https://t.zsxq.com/naaMf6y 博客 1.Flink 从0到1学习 -- Apache Flink 介绍 2.Flink 从0到1学习 -- Mac 上搭建 F ...