UOJ#55. 【WC2014】紫荆花之恋
传送门
暴力思路就是每次点分治计算答案
点分治之后,条件可以变成 \(dis_i-r_i\le r_j-dis_j\)
每次只要查找 \(r_j-dis_j\) 的排名然后插入 \(dis_j-r_j\),随便拿个平衡树维护即可
考虑如果带修改,就是动态点分治,每个点维护两个平衡树,一个表示自己的贡献,一个表示上一层重心要减去的在同一棵子树的贡献
每次加入一个点就直接在父亲下面,暴力向上更新每一个重心的两个平衡树,顺便查询答案
求距离什么的直接暴力维护倍增数组就行了
现在的问题就是可能暴力向上更新的时候链长过大
这个时候运用替罪羊树的思想,维护一个 \(size\),不平衡就暴力重构这个点分树子树的所有信息即可
把1e9看成是1e9+7调了一年
# include <bits/stdc++.h>
using namespace std;
typedef long long ll;
namespace IO {
const int maxn(1 << 21 | 1);
char ibuf[maxn], obuf[maxn], *iS, *iT, *oS = obuf, *oT = obuf + maxn - 1, c, st[66];
int tp, f;
inline char Getc() {
return iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, maxn, stdin), (iS == iT ? EOF : *iS++)) : *iS++;
}
template <class Int> inline void In(Int &x) {
for (f = 1, c = Getc(); c < '0' || c > '9'; c = Getc()) f = c == '-' ? -1 : 1;
for (x = 0; c >= '0' && c <= '9'; c = Getc()) x = (x << 1) + (x << 3) + (c ^ 48);
x *= f;
}
inline void Flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void Putc(char c) {
*oS++ = c;
if (oS == oT) Flush();
}
template <class Int> void Out(Int x) {
if (!x) Putc('0');
if (x < 0) Putc('-'), x = -x;
while (x) st[++tp] = x % 10 + '0', x /= 10;
while (tp) Putc(st[tp--]);
}
}
using IO :: In;
using IO :: Out;
using IO :: Putc;
using IO :: Flush;
const int maxn(2e5 + 5);
const int maxm(8e6 + 5);
const int mod(1e9);
const double alpha(0.75);
namespace BT {
int ls[maxm], rs[maxm], size[maxm], val[maxm], trash[maxm], top, tot, que[maxm], len, rt[maxn];
inline int NewNode(int v) {
int o = top ? trash[top--] : ++tot;
assert(tot < maxm);
ls[o] = rs[o] = 0, size[o] = 1, val[o] = v;
return o;
}
void Recycle(int x) {
if (!x) return;
trash[++top] = x, Recycle(ls[x]), Recycle(rs[x]);
}
inline void Clear(int x) {
Recycle(rt[x]), rt[x] = 0;
}
void Rebuild(int x) {
if (!x) return;
Rebuild(ls[x]), que[++len] = x, Rebuild(rs[x]);
}
int Build(int l, int r) {
if (l > r) return 0;
int mid = (l + r) >> 1, o = que[mid];
ls[o] = Build(l, mid - 1), rs[o] = Build(mid + 1, r);
size[o] = size[ls[o]] + size[rs[o]] + 1;
return o;
}
void Insert(int &x, int v) {
if (!x) x = NewNode(v);
else {
if (alpha * size[x] < max(size[ls[x]], size[rs[x]])) len = 0, Rebuild(x), x = Build(1, len);
v <= val[x] ? Insert(ls[x], v) : Insert(rs[x], v);
size[x] = size[ls[x]] + size[rs[x]] + 1;
}
}
int Kth(int x, int v) {
if (!x) return 0;
if (v >= val[x]) return Kth(rs[x], v) + size[ls[x]] + 1;
return Kth(ls[x], v);
}
}
int n, r[maxn], first[maxn], cnt, dis[maxn], fa[maxn][18], deep[maxn], frt[maxn], vis[maxn], idx;
int sz[maxn], nsz, mx[maxn], rt, mark[maxn], size[maxn];
struct Edge {
int to, next, w;
} edge[maxn];
inline void Add(int u, int v, int w) {
edge[cnt] = (Edge){v, first[u], w}, first[u] = cnt++;
edge[cnt] = (Edge){u, first[v], w}, first[v] = cnt++;
}
inline int LCA(int x, int y) {
int i;
if (deep[x] < deep[y]) swap(x, y);
for (i = 17; ~i; --i)
if (deep[fa[x][i]] >= deep[y]) x = fa[x][i];
if (x == y) return x;
for (i = 17; ~i; --i)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
inline int Dis(int x, int y) {
return dis[x] + dis[y] - (dis[LCA(x, y)] << 1);
}
void Clear(int u, int ff) {
int e, v;
mark[u] = 0, BT :: Clear(u), BT :: Clear(u + n);
for (e = first[u]; ~e; e = edge[e].next)
if (((v = edge[e].to) ^ ff) && (vis[v] ^ idx)) Clear(v, u);
}
void Getroot(int u, int ff) {
int e, v;
sz[u] = 1, mx[u] = 0;
for (e = first[u]; ~e; e = edge[e].next)
if (((v = edge[e].to) ^ ff) && (vis[v] ^ idx)) {
Getroot(v, u);
sz[u] += sz[v], mx[u] = max(mx[u], sz[v]);
}
mx[u] = max(mx[u], nsz - sz[u]);
if (!rt || mx[u] < mx[rt]) rt = u;
}
void Getdis(int u, int ff, int nrt, int d) {
int e, v;
BT :: Insert(BT :: rt[nrt], d - r[u]);
if (frt[nrt]) BT :: Insert(BT :: rt[nrt + n], Dis(frt[nrt], u) - r[u]);
for (e = first[u]; ~e; e = edge[e].next)
if (((v = edge[e].to) ^ ff) && (vis[v] ^ idx)) Getdis(v, u, nrt, d + edge[e].w);
}
void Build(int u) {
int e, v;
vis[u] = idx, Getdis(u, 0, u, 0);
for (e = first[u]; ~e; e = edge[e].next)
if (vis[v = edge[e].to] ^ idx) {
rt = 0, nsz = sz[v], Getroot(v, u);
frt[rt] = u, size[rt] = sz[v], Build(rt);
}
}
inline void Rebuild(int u) {
int x;
for (++idx, x = frt[u]; x; x = frt[x]) vis[x] = idx;
Clear(u, 0), rt = 0, nsz = size[u], Getroot(u, 0);
frt[rt] = frt[u], size[rt] = sz[u], Build(rt);
}
void Update(int u, int v, ll &ans) {
if (!frt[u]) {
if (mark[u]) Rebuild(u);
return;
}
int d = Dis(frt[u], v);
ans += BT :: Kth(BT :: rt[frt[u]], r[v] - d);
BT :: Insert(BT :: rt[frt[u]], d - r[v]);
ans -= BT :: Kth(BT :: rt[u + n], r[v] - d);
BT :: Insert(BT :: rt[u + n], d - r[v]);
++size[frt[u]];
if (frt[u] && alpha * size[frt[u]] < size[u]) mark[frt[u]] = 1;
Update(frt[u], v, ans);
if (mark[u]) Rebuild(u);
}
int main() {
int i, c, j;
ll ans = 0;
memset(first, -1, sizeof(first)), deep[1] = 1;
In(c), In(n);
for (i = 1; i <= n; ++i) {
In(fa[i][0]), In(c), In(r[i]);
fa[i][0] ^= ans % mod;
if (fa[i][0]) {
Add(fa[i][0], i, c);
for (j = 1; j <= 17; ++j) fa[i][j] = fa[fa[i][j - 1]][j - 1];
}
deep[i] = deep[fa[i][0]] + 1, dis[i] = dis[fa[i][0]] + c;
frt[i] = fa[i][0], size[i] = 1;
BT :: Insert(BT :: rt[i], -r[i]), Update(i, i, ans);
Out(ans), Putc('\n');
}
return Flush(), 0;
}
UOJ#55. 【WC2014】紫荆花之恋的更多相关文章
- UOJ#55 [WC2014]紫荆花之恋
题目描述 强强和萌萌是一对好朋友.有一天他们在外面闲逛,突然看到前方有一棵紫荆树.这已经是紫荆花飞舞的季节了,无数的花瓣以肉眼可见的速度从紫荆树上长了出来. 仔细看看的话,这个大树实际上是一个带权树. ...
- bzoj 3435: [Wc2014]紫荆花之恋 替罪羊树维护点分治 && AC400
3435: [Wc2014]紫荆花之恋 Time Limit: 240 Sec Memory Limit: 512 MBSubmit: 159 Solved: 40[Submit][Status] ...
- 【BZOJ3435】[Wc2014]紫荆花之恋 替罪点分树+SBT
[BZOJ3435][Wc2014]紫荆花之恋 Description 强强和萌萌是一对好朋友.有一天他们在外面闲逛,突然看到前方有一棵紫荆树.这已经是紫荆花飞舞的季节了,无数的花瓣以肉眼可见的速度从 ...
- BZOJ 3435: [Wc2014]紫荆花之恋
二次联通门 : BZOJ 3435: [Wc2014]紫荆花之恋 二次联通门 : luogu P3920 [WC2014]紫荆花之恋 /* luogu P3920 [WC2014]紫荆花之恋 怀疑人生 ...
- luogu P3920 [WC2014]紫荆花之恋
LINK:紫荆花之恋 每次动态加入一个节点 统计 有多少个节点和当前节点的距离小于他们的权值和. 显然我们不能n^2暴力. 考虑一个简化版的问题 树已经给出 每次求某个节点和其他节点的贡献. 不难想到 ...
- BZOJ3435 & 洛谷3920 & UOJ55:[WC2014]紫荆花之恋
https://www.lydsy.com/JudgeOnline/problem.php?id=3435 https://www.luogu.org/problemnew/show/P3920 ht ...
- BZOJ3435[Wc2014]紫荆花之恋——动态点分治(替罪羊式点分树套替罪羊树)
题目描述 强强和萌萌是一对好朋友.有一天他们在外面闲逛,突然看到前方有一棵紫荆树.这已经是紫荆花飞舞的季节了,无数的花瓣以肉眼可见的速度从紫荆树上长了出来.仔细看看的话,这个大树实际上是一个带权树.每 ...
- [WC2014]紫荆花之恋(动态点分治+替罪羊思想)
题目描述 强强和萌萌是一对好朋友.有一天他们在外面闲逛,突然看到前方有一棵紫荆树.这已经是紫荆花飞舞的季节了,无数的花瓣以肉眼可见的速度从紫荆树上长了出来.仔细看看的话,这个大树实际上是一个带权树.每 ...
- 【bzoj3435】[Wc2014]紫荆花之恋 替罪点分树套SBT
题目描述 强强和萌萌是一对好朋友.有一天他们在外面闲逛,突然看到前方有一棵紫荆树.这已经是紫荆花飞舞的季节了,无数的花瓣以肉眼可见的速度从紫荆树上长了出来.仔细看看的话,这个大树实际上是一个带权树.每 ...
- BZOJ3435: [Wc2014]紫荆花之恋(替罪羊树,Treap)
Description 强强和萌萌是一对好朋友.有一天他们在外面闲逛,突然看到前方有一棵紫荆树.这已经是紫荆花飞舞的季节了,无数的花瓣以肉眼可见的速度从紫荆树上长了出来.仔细看看的话,这个大树实际上是 ...
随机推荐
- eclipse的classpath(build path)和classpaht几种设置的方式
1,默认eclipse有自己的classpath的路径并不是环境变量中配置的classpah. 2,eclipse的classpath每个项目不同,一般是在工作区的当前项目的class下. 2.1,可 ...
- C++实现二叉树的相应操作
1. 二叉树的遍历:先序(递归.非递归),中序(递归.非递归),后序(递归.非递归). #include <iostream> #include <string> #inclu ...
- 总结day26 ----验证客户端的合法性,已经操作系统,进程的简单初识别
前情提要 一:验证客户端的合法性: # .需要认证 # 程序和用户打交道的时候才会用到用户认证 # 对所有的客户端进行统一的认证 # # 我现在要做的事情 # 写一个server端 # 写一个clie ...
- SAE实践——用SVN命令行同步/提交代码
1. 同步应用到本地 注:首次使用svn需要输入安全认证密码 在终端输入以下命令 svn co https://svn.sinaapp.com/nyhello nyhello替换为自己的应用名称. 用 ...
- Python的垃圾回收机制以及引用计数
Python中的计数引用 在Python中,由于Python一门动态的语言,内部采用的指针形式对数据进行标记的,并不像c/c++那样,通过指定的数据类型并分配相应的数据空间,Python中定义的变量名 ...
- linux克隆后修配置
第一步:克隆 第二步:vi /etc/sysconfig/network-scripts/ifcfg-eth0 编辑 DEVICE=eth0 TYPE=Ethernet ONBOOT=yes NM ...
- smtp自动发送邮件demo
using System; using System.Collections.Generic; using System.IO; using System.Linq; using System.Net ...
- [转] spark-submit 提交任务及参数说明
[From] https://www.cnblogs.com/weiweifeng/p/8073553.html#undefined spark-submit 可以提交任务到 spark 集群执行,也 ...
- 数学还勉强管用,用代码还能画个canvas 仪表盘(含完整代码)
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...
- DB2 体系结构 (进程模型)
DB2 是众多关系型数据库中的一种, 关系型数据库还包括比较火的Oracle,MySQL 实例 数据库 DB2 进程模型 DB2 通过 db2start 命令启动数据库实例,即启动相应的进程和线程,并 ...