如题,已知一棵包含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,分别表示树的结点个数、操作个数、根节点序号和取模数(即所有的输出结果均对此取模)。
接下来一行包含N个非负整数,分别依次表示各个节点上初始的数值。
接下来N-1行每行包含两个整数x、y,表示点x和点y之间连有一条边(保证无环且连通)
接下来M行每行包含若干个正整数,每行表示一个操作,格式如下:
操作1: 1 x y z
操作2: 2 x y
操作3: 3 x z
操作4: 4 x
输出包含若干行,分别依次表示每个操作2或操作4所得的结果(对P取模)
5 5 2 24
7 3 7 8 0
1 2
1 5
3 1
4 1
3 4 2
3 2 2
4 5
1 5 1 3
2 1 3
2
21
时空限制:1s,128M
数据规模:
对于30%的数据: N≤10,M≤10N≤10,M≤10 N ≤ 10 , M ≤ 10 N ≤ 10 , M ≤ 10
对于70%的数据: N≤103,M≤103N≤103,M≤103 N ≤ 10 3 , M ≤ 10 3 N ≤ 103 , M ≤ 103
对于100%的数据: N≤105,M≤105N≤105,M≤105 N ≤ 10 5 , M ≤ 10 5 N ≤ 105 , M ≤ 105
(
其实,纯随机生成的树LCA+暴力是能过的,可是,你觉得可能是纯随机的么233)样例说明:
树的结构如下:
各个操作如下:
故输出应依次为2、21(重要的事情说三遍:记得取模)
这是一道树链剖分的模板题:
因为树的状态是不变的,因此树链剖分的策略是将这些点按某种方式组织起来,剖分为若干条链,每条链就相当于一个序列。这样,操作的路径可以拆分为某几条链,也就是若干个完整序列或是某个序列上的一段区间,此时可以用线段树等处理序列上区间新操作的数据结构去解决问题。树链剖分的核心是如何恰当的将树剖分为若干条链,当链的划分方式确定时,只需要将他们看作一个个序列,将所有的序列按照顺序拼接起来,每条链就形成了一个区间,而序列上的区间问题使我们擅长解决的.
关于树链剖分,有如下几个定义:
在剖分过程中,要计算如下7个值:
第一遍dfs时可以计算前4个值,第二遍dfs后可以计算后3个值,在计算id时,同一条重链上的点需要按顺序排在连继续的一段位置,也就是一段区间.
将一条路径(u,v)拆分成若干重链的过程,实际上就是寻找最近公共祖先的过程。我们会选择u,v中深度较大的点向上走一步,知道u==v.现在有了重链,由于我们记录了重链的顶部节点top[x],还记录了每个点在序列中的位置,因为我们不需要一步步走。假定top[u]和top[v]不同,那么他们的最近公共祖先可能在其中的一条重链上,也可能在其他重链上。因为LCA显然不可能在top深度较大的那条重链上,所以我们先处理top深度较大的。首先我们找出u,v中top深度较大的点,假设是u,则可以直接调到fa[top[u]]
处,且跳过的这一段,在线段树中是一段区间,若我们按照深度从小到大来存储点,则这段区间为:[id[top[x]],id[x]]
。当u,v中的top相同时,说明他们走到了同一条重链上,这时他们之间的路径也是序列上的一段区间,且u,v中深度较小的点是原路径的LCA.这样我们就可以将给出的任意路径拆分为若干个重链,也就是若干个区间,可以用线段树来处理操作。
#include
using namespace std;
#define mem(a, b) memset(a, b, sizeof(a))
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1
const int N = 2e5 + 10;
int sum[N << 2], lazy[N << 2]; //线段树求和
int n, m, r, mod; //节点数,操作数,根节点,模数
int first[N], tot; //邻接表
//分别为:重儿子,每个节点新编号,父亲,编号,深度,子树个数,所在重链的顶部
int son[N], id[N], fa[N], cnt, dep[N], siz[N], top[N];
int w[N], wt[N]; //初始点权,新编号点权
int res = 0; //查询答案
struct edge
{
int v, next;
} e[N];
void add_edge(int u, int v)
{
e[tot].v = v;
e[tot].next = first[u];
first[u] = tot++;
}
void init()
{
mem(first, -1);
tot = 0;
cnt = 0;
}
int pushup(int rt)
{
sum[rt] = (sum[rt << 1] + sum[rt << 1 | 1]) % mod;
}
void pushdown(int rt, int m) //下放lazy标记
{
if (lazy[rt])
{
lazy[rt << 1] += lazy[rt]; //给左儿子下放lazy
lazy[rt << 1 | 1] += lazy[rt]; //给右儿子下放lazy
sum[rt << 1] += lazy[rt] * (m - (m >> 1)); //更新sum
sum[rt << 1] %= mod;
sum[rt << 1 | 1] += lazy[rt] * (m >> 1);
sum[rt << 1 | 1] %= mod;
lazy[rt] = 0;
}
}
void build(int l, int r, int rt)
{
lazy[rt] = 0;
if (l == r)
{
sum[rt] = wt[l]; //新的编号点权
sum[rt] %= mod;
return;
}
int m = (l + r) >> 1;
build(lson);
build(rson);
pushup(rt);
}
void update(int L, int R, int c, int l, int r, int rt)
{
if (L <= l && r <= R)
{
lazy[rt] += c;
sum[rt] += c * (r - l + 1);
sum[rt] %= mod;
return;
}
pushdown(rt, r - l + 1);
int m = (l + r) >> 1;
if (L <= m)
update(L, R, c, lson);
if (R > m)
update(L, R, c, rson);
pushup(rt);
}
void query(int L, int R, int l, int r, int rt)
{
if (L <= l && r <= R)
{
res += sum[rt];
res %= mod;
return;
}
pushdown(rt, r - l + 1);
int m = (l + r) >> 1;
if (L <= m)
query(L, R, lson);
if (R > m)
query(L, R, rson);
}
//----------------------------------------------------------------
//处理出fa[],dep[],siz[],son[]
void dfs1(int u, int f, int deep)
{
dep[u] = deep; //标记深度
fa[u] = f; //标记节点的父亲
siz[u] = 1; //记录每个节点子树大小
int maxson = -1; //记录重儿子数量
for (int i = first[u]; ~i; i = e[i].next)
{
int v = e[i].v;
if (v == f)
continue;
dfs1(v, u, deep + 1);
siz[u] += siz[v];
if (siz[v] > maxson) //儿子里最多siz就是重儿子
{
son[u] = v; //标记u的重儿子为v
maxson = siz[v];
}
}
}
//处理出top[],wt[],id[]
void dfs2(int u, int topf)
{
id[u] = ++cnt; //每个节点的新编号
wt[cnt] = w[u]; //新编号的对应权值
top[u] = topf; //标记每个重链的顶端
if (!son[u]) //没有儿子时返回
return;
dfs2(son[u], topf); //搜索下一个重儿子
for (int i = first[u]; ~i; i = e[i].next)
{
int v = e[i].v;
if (v == fa[u] || v == son[u]) //处理轻儿子
continue;
dfs2(v, v); //每一个轻儿子都有一个从自己开始的链
}
}
void updrange(int x, int y, int k)
{
k %= mod;
while (top[x] != top[y])
{
if (dep[top[x]] < dep[top[y]]) //使x深度较大
swap(x, y);
update(id[top[x]], id[x], k, 1, n, 1);
x = fa[top[x]];
}
if (dep[x] > dep[y]) //使x深度较小
swap(x, y);
update(id[x], id[y], k, 1, n, 1);
}
int qrange(int x, int y)
{
int ans = 0;
while (top[x] != top[y]) //当两个点不在同一条链上
{
if (dep[top[x]] < dep[top[y]]) //使x深度较大
swap(x, y);
res = 0;
query(id[top[x]], id[x], 1, n, 1);
//ans加上x点到x所在链顶端这一段区间的点权和
ans += res;
ans %= mod;
x = fa[top[x]]; //x跳到x所在链顶端的这个点的上面一个点
}
//当两个点处于同一条链
if (dep[x] > dep[y]) //使x深度较小
swap(x, y);
res = 0;
query(id[x], id[y], 1, n, 1);
ans += res;
return ans % mod;
}
void upson(int x, int k)
{
update(id[x], id[x] + siz[x] - 1, k, 1, n, 1); //子树区间右端点为id[x]+siz[x]-1
}
int qson(int x)
{
res = 0;
query(id[x], id[x] + siz[x] - 1, 1, n, 1);
return res;
}
int main()
{
// freopen("in.txt", "r", stdin);
int u, v;
scanf("%d%d%d%d", &n, &m, &r, &mod);
init();
for (int i = 1; i <= n; i++)
scanf("%d", &w[i]);
for (int i = 1; i <= n - 1; i++)
{
scanf("%d%d", &u, &v);
add_edge(u, v);
add_edge(v, u);
}
dfs1(r, 0, 1);
dfs2(r, r);
build(1, n, 1); //用新点权建立线段树
while (m--)
{
int op, x, y, z;
scanf("%d", &op);
if (op == 1)
{
scanf("%d%d%d", &x, &y, &z);
updrange(x, y, z);
}
else if (op == 2)
{
scanf("%d%d", &x, &y);
printf("%d\n", qrange(x, y));
}
else if (op == 3)
{
scanf("%d%d", &x, &z);
upson(x, z);
}
else if (op == 4)
{
scanf("%d", &x);
printf("%d\n", qson(x));
}
}
return 0;
}