51nod 1462 树据结构 | 树链剖分矩阵乘法

题目链接

题目描述

给一颗以1为根的树。

每个点有两个权值：vi, ti,一开始全部是零。

Q次操作：

读入o, u, d

o = 1 对u到根上所有点的vi += d

o = 2 对u到根上所有点的ti += vi * d

最后,输出每个点的ti值(n, Q <= 100000)

有50%的数据N,Q <= 10000

注：所有数64位整数不会爆。

题解

这道题好神奇啊……看讨论版里的 AntiLeaf 大神的矩阵乘法打标记才找到思路，然后又看到 ccz181078 的评论，发现常数可以优化到这么小……真是太神了！一月份听尹涵学姐提到过矩阵乘法结合线段树，今天终于做到这样的题了2333

好的说题解。

可以发现（我并没发现），题中的两种操作都可以用矩阵来表示。假如用下面这个矩阵表示一个节点的状态

\[\begin{bmatrix}1 & v & t\end{bmatrix}
\]

那么操作1可以表示为

\[\begin{bmatrix}1 & v & t\end{bmatrix} *\begin{bmatrix}1 & d & 0\\0 & 1 & 0\\0 & 0 & 1\end{bmatrix}=\begin{bmatrix}1 & v + d & t\end{bmatrix}
\]

（可以看出那个1就是用来给v加上d的）

然后操作2可以表示为

\[\begin{bmatrix}1 & v & t\end{bmatrix} *\begin{bmatrix}1 & 0 & 0\\0 & 1 & d\\0 & 0 & 1\end{bmatrix}=\begin{bmatrix}1 & v & t + v * d\end{bmatrix}
\]

这样两种操作就都可以通过矩阵来做啦。

然后根据题目要求显然需要树链剖分，线段树上维护矩阵就可以了。矩阵乘法满足结合律，所以可以正常地下放lazy标记。

但是这个矩阵乘法常数比较大（矩阵乘法$O(n^3)$，$n^3 = 27$）。但是这个矩阵比较特殊，它左下角三个位置恒为0，主对角线恒为1，于是并不需要$O(n^3)$地做矩阵乘法，实际上只需要4次加法和1次乘法，这是一个显著的常数优化！

代码：

#include <cstdio>

#include <cstring>

#include <cmath>

#include <algorithm>

#include <iostream>

#include <vector>

#define space putchar(' ')

#define enter putchar('\n')

typedef long long ll;

using namespace std;

template <class T>

void read(T &x){

    char c;

    bool op = 0;

    while(c = getchar(), c < '0' || c > '9')

	if(c == '-') op = 1;

    x = c - '0';

    while(c = getchar(), c >= '0' && c <= '9')

	x = x * 10 + c - '0';

    if(op) x = -x;

}

template <class T>

void write(T x){

    if(x < 0) putchar('-'), x = -x;

    if(x >= 10) write(x / 10);

    putchar('0' + x % 10);

}

const int N = 100005;

int n, m, adj[N], nxt[N];

int fa[N], son[N], sze[N], top[N], pos[N], idx[N], tot;

ll ans[N];

struct matrix {

    ll g[3][3];

    matrix(){

	memset(g, 0, sizeof(g));

    }

    matrix(int x){

	memset(g, 0, sizeof(g));

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

	    g[i][i] = 1;

    }

    bool empty(){

	return !g[0][1] && !g[0][2] && !g[1][2];

    }

    void clear(){

	g[0][1] = g[0][2] = g[1][2] = 0;

    }

    friend matrix opt_multi(const matrix &a, const matrix &b){

	matrix c(1);

	c.g[0][1] = a.g[0][1] + b.g[0][1];

	c.g[1][2] = a.g[1][2] + b.g[1][2];

	c.g[0][2] = a.g[0][2] + b.g[0][2] + a.g[0][1] * b.g[1][2];

	return c;

    }

} lazy[4*N];

void pushdown(int k){

    lazy[k << 1] = opt_multi(lazy[k << 1], lazy[k]);

    lazy[k << 1 | 1] = opt_multi(lazy[k << 1 | 1], lazy[k]);

    lazy[k].clear();

}

void change(int k, int l, int r, int ql, int qr, const matrix &x){

    if(ql <= l && qr >= r) return (void)(lazy[k] = opt_multi(lazy[k], x));

    if(!lazy[k].empty()) pushdown(k);

    int mid = (l + r) >> 1;

    if(ql <= mid) change(k << 1, l, mid, ql, qr, x);

    if(qr > mid) change(k << 1 | 1, mid + 1, r, ql, qr, x);

}

void pushdown_all(int k, int l, int r){

    if(l == r) return (void)(ans[idx[l]] = lazy[k].g[0][2]);

    if(!lazy[k].empty()) pushdown(k);

    int mid = (l + r) >> 1;

    pushdown_all(k << 1, l, mid);

    pushdown_all(k << 1 | 1, mid + 1, r);

}

void add(int u, int v){

    nxt[v] = adj[u];

    adj[u] = v;

}

void bfs(){

    static int que[N], qr;

    que[qr = 1] = 1;

    for(int ql = 1; ql <= qr; ql++)

	for(int u = que[ql], v = adj[u]; v; v = nxt[v])

	    que[++qr] = v;

    for(int ql = qr, u; ql; ql--){

	u = que[ql];

	sze[fa[u]] += ++sze[u];

	if(sze[u] > sze[son[fa[u]]]) son[fa[u]] = u;

    }

    for(int ql = 1, u; ql <= qr; ql++)

	if(!top[u = que[ql]])

	    for(int v = u; v; v = son[v])

		top[v] = u, idx[pos[v] = ++tot] = v;

}

void path_change(int o, int u, ll d){

    matrix x(1);

    (o == 1 ? x.g[0][1] : x.g[1][2]) = d;

    while(u){

	change(1, 1, n, pos[top[u]], pos[u], x);

	u = fa[top[u]];

    }

}

int main(){

    read(n);

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

	read(fa[i]), add(fa[i], i);

    bfs();

    read(m);

    while(m--){

	int o, u;

	ll d;

	read(o), read(u), read(d);

	path_change(o, u, d);

    }

    pushdown_all(1, 1, n);

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

	write(ans[i]), enter;

    return 0;

}