【洛谷P4719】动态dp

Description

给定一棵树，点带点权，允许修改点权，求每次修改之后树的最大独立集

Solution

ddp用LCT维护

前置知识（静态树的最大独立集问题）

首先，我们要明确静态树的最大独立集的解法

定义$f[i][0/1]$表示在以$i$为根的子树中，该节点选/不选的最大权值，那么有状态转移方程

$$\left\{
\begin{matrix}
f[i][0]=\sum\limits_{j\in son(i)}{max\{f[j][0],f[j][1]\}} \\
f[i][1]=val[i]+\sum\limits_{j\in son(i)}{f[j][0]}
\end{matrix}
\right.
$$

我们可以通过一遍dfs在$O(n)$的时间内求出

简化版问题

假定现在这道题不是一棵树而是一个序列，允许修改点权，并且要求求出若干个两两不相邻的点的最大权值和

状态定义类似：定义$f[i][0/1]$表示在前$i$个元素中，$i$选/不选的最大权值，那么有状态转移方程

$$\left\{
\begin{matrix}
f[i][0]=max\{f[i-1][1],f[i-1][0]\} \\
f[i][1]=val[i]+f[i-1][0]
\end{matrix}
\right.
$$

矩阵优化转移

我们将转移用矩阵进行优化，并且重新定义矩阵乘法的含义，假定$C=A\times B$，那么有

$$C_{i,j}=\max\limits_{k\in [1, j]}\{A_{i,k}+B_{k,j}\}$$

因此，转移可以写成这样

$$
\begin{bmatrix}
0 & 0 \\
val[i] & -\infty
\end{bmatrix}
\times
\begin{bmatrix}
f[i-1][0] \\
f[i-1][1]
\end{bmatrix}
=
\begin{bmatrix}
f[i][0] \\
f[i][1]
\end{bmatrix}
$$

所以我们转移时将这些矩阵乘起来就好了

可以用线段树维护，时间复杂度$O(mlogn)$

（真的）动态dp

现在我们把这个问题搬到了树上

再套一个LCT维护即可

我们定义状态，$g[i][1/0]$表示在以$i$为根的子树中，轻儿子及其子树的dp值，那么有状态转移方程

$$\left\{
\begin{matrix}
g[i][0]=\sum\limits_{j\in lightson(i)}{max\{f[j][0],f[j][1]\}} \\
g[i][1]=val[i]+\sum\limits_{j\in lightson(i)}{f[j][0]}
\end{matrix}
\right.
$$

同时，$f$也可以维护：

$$\left\{
\begin{matrix}
f[i][0]=g[i][0]+ \max\{f[i.heavyson][0],f[i.heavyson][1]\} \\
f[i][1]=g[i][1]+f[i.heavyson][0]
\end{matrix}
\right.
$$

同样用矩阵优化转移：

$$
\begin{bmatrix}
g[i][0] & g[i][0] \\
g[i][1] & -\infty
\end{bmatrix}
\times
\begin{bmatrix}
f[i.heavyson][0] \\
f[i.heavyson][1]
\end{bmatrix}
=
\begin{bmatrix}
f[i][0] \\
f[i][1]
\end{bmatrix}
$$

这样，我们用LCT就能维护这个dp了

时间复杂度为$O(mlogn)$

Code

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5 + 10;
const int INF = 0x3f3f3f3f;
inline int read() {
    int ret = 0, op = 1;
    char c = getchar();
    while (!isdigit(c)) {
        if (c == '-') op = -1; 
        c = getchar();
    }
    while (isdigit(c)) {
        ret = (ret << 3) + (ret << 1) + c - '0';
        c = getchar();
    }
    return ret * op;
}
struct Edge {
    int nxt, to;
} e[N << 1];
struct Matrix {
    int m[2][2];
    Matrix() {memset(m, 0, sizeof(m));}
    inline void build(int x, int y) {
        m[0][0] = m[0][1] = x;
        m[1][0] = y; m[1][1] = -INF;
    }
    inline int getmax() {
        return max(m[0][0], m[1][0]);
    }
    Matrix operator *(const Matrix &x) const {
        Matrix ret;
        for (register int i = 0; i < 2; ++i)
            for (register int j = 0; j < 2; ++j)
                for (register int k = 0; k < 2; ++k)
                    ret.m[i][j] = max(ret.m[i][j], m[i][k] + x.m[k][j]);
        return ret; 
    }
};
struct LCT {
    int fa, ch[2], f[2];
    Matrix x;
} a[N];
int num, head[N], n, m, val[N];
inline void add(int from, int to) {
    e[++num].nxt = head[from];
    e[num].to = to;
    head[from] = num;
}
void dfs(int now, int fa) {
    a[now].f[1] = val[now];
    for (register int i = head[now]; i; i = e[i].nxt) {
        int to = e[i].to;
        if (to == fa) continue ;
        a[to].fa = now;
        dfs(to, now);
        a[now].f[0] += max(a[to].f[0], a[to].f[1]);
        a[now].f[1] += a[to].f[0];
    }
    a[now].x.build(a[now].f[0], a[now].f[1]);
}
inline int isnroot(int now) {
    return a[a[now].fa].ch[1] == now || a[a[now].fa].ch[0] == now;
}
inline void update(int now) {
    a[now].x.build(a[now].f[0], a[now].f[1]);
    if (a[now].ch[0]) a[now].x = a[a[now].ch[0]].x * a[now].x;
    if (a[now].ch[1]) a[now].x = a[now].x * a[a[now].ch[1]].x;
}
inline void rotate(int x) {
    int y = a[x].fa;
    int z = a[y].fa;
    int xson = a[y].ch[1] == x;
    int yson = a[z].ch[1] == y;
    int B = a[x].ch[xson ^ 1];
    if (isnroot(y)) a[z].ch[yson] = x;
    a[y].ch[xson] = B;
    a[x].ch[xson ^ 1] = y;
    if (B) a[B].fa = y;
    a[y].fa = x;
    a[x].fa = z;
    update(y);
    update(x);
}
void splay(int x) {
    while (isnroot(x)) {
        int y = a[x].fa;
        int z = a[y].fa;
        if (isnroot(y))
            (a[y].ch[0] == x) ^ (a[z].ch[0] == y) ? rotate(x) : rotate(y); 
        rotate(x);
    }
    update(x);
}
void access(int x) {
    for (register int y = 0; x; y = x, x = a[x].fa) {
        splay(x);
        if (a[x].ch[1]) {
            a[x].f[0] += a[a[x].ch[1]].x.getmax();
            a[x].f[1] += a[a[x].ch[1]].x.m[0][0];
        }
        if (y) {
            a[x].f[0] -= a[y].x.getmax();
            a[x].f[1] -= a[y].x.m[0][0];
        }
        a[x].ch[1] = y;
        update(x);
    }
}
int main() {
    n = read(); m = read();
    for (register int i = 1; i <= n; ++i) val[i] = read();
    for (register int i = 1; i < n; ++i) {
        int x = read(), y = read();
        add(x, y); add(y, x);
    }
    dfs(1, 0);
    while (m--) {
        int x = read();
        int y = read();
        access(x);
        splay(x);
        a[x].f[1] += y - val[x];
        val[x] = y;
        update(x);
        splay(1);
        printf("%d\n", a[1].x.getmax());
    }
    return 0;
}