动态 DP 学习笔记

动态 DP

P4719 动态 DP

给定一棵 $n$ ($n⩽{10}^5$) 个点的树，点带点权。

有 $m$ ($m⩽{10}^5$) 次操作，每次操作给定 $x,y$，表示修改点 $x$ 的权值为 $y$。

你需要在每次操作之后求出这棵树的最大权独立集的权值大小。

首先考虑 $m=0$ 时的做法，可以简单地设计出 dp 转移方程式 $f_{x,0/1}$ 表示 $x$ 选或不选的答案。

$$\{\begin{array}{l}{f}_{x,0}=\sum _{v\in x.\text{son}}max\{f_{v,1},f_{v,0}\}\\ f_{x,1}=p_x+\sum _{v\in x.\text{son}}{f}_{v,0}\end{array}$$

考虑用矩阵乘法维护这个东西，这个东西显然不能写成矩阵乘法的形式，故考虑广义矩阵乘法。

广义矩阵乘法

比如此题中的矩阵惩罚可以长这个样子：

$$C_{i,j}=\underset{k=0}{\overset{size-1}{max}}(A_{i,k}+B_{k,j})$$

可以发现，就是将普通矩阵乘法中的加换成了 $max$，乘法换成了加法。

对应到上面的递推式，可以添加辅助数组 $g$，$g_{x,0/1}$ 表示不考虑 $x$ 的实儿子的情况下，选或不选 $x$ 的答案：

$$\begin{gathered} \{\begin{array}{l}{g}_{x,0}=\sum _{v\in x.\text{son}\wedge v\ne so{n}_x}max\{f_{v,0},f_{v,1}\}\\ g_{x,1}=p_x+\sum _{v\in x.\text{son}\wedge v\ne so{n}_x}{f}_{v,0}\\ f_{x,0}=g_{x,0}+max\{f_{so{n}_x,0},f_{so{n}_x,1}\}\\ f_{x,1}=g_{x,1}+f_{so{n}_x,0}\end{array} \\ \left[\begin{array}{cc}{g}_{x,0}& g_{x,0}\\ g_{x,1}& -\mathrm{\infty }\end{array}\right]\times \left[\begin{array}{c}{f}_{so{n}_x,0}\\ f_{so{n}_x,1}\end{array}\right]=\left[\begin{array}{c}{f}_{x,0}\\ f_{x,1}\end{array}\right] \end{gathered}$$

然后下面的这坨东西是可以用线段树维护的，接着就可以树剖了。

代码

#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
#define int i64
const int N = 1E5 + 5;
const int inf = 0x3f3f3f3f;
int n, m, p[N];
vector <int> G[N];
int sz[N], son[N], top[N], dfn[N], tot, fa[N], dep[N], wt[N];
int f[N][2], g[N][2], epos[N];
void dfs1(int x) {
  sz[x] = 1; pair <int, int> mx = make_pair(0, 0);
  f[x][1] = p[x]; f[x][0] = 0;
  for (auto v : G[x]) {
    if (v == fa[x]) continue;
    fa[v] = x; dep[v] = dep[x] + 1;
    dfs1(v); sz[x] += sz[v];
    mx = max(mx, make_pair(sz[v], v));
    f[x][0] += max(f[v][0], f[v][1]);
    f[x][1] += f[v][0];
  } son[x] = mx.second;
}
void dfs2(int x, int topf) {
  top[x] = topf; wt[dfn[x] = ++tot] = x;
  g[x][1] = p[x];
  if (!son[x]) return void(epos[topf] = tot);
  dfs2(son[x], topf);
  for (auto v : G[x]) {
    if (v == son[x] || v == fa[x]) continue;
    dfs2(v, v);
    g[x][0] += max(f[v][0], f[v][1]);
    g[x][1] += f[v][0];
  }
}
struct mat {
  int a[2][2];
  mat () {
    a[0][0] = a[1][0] = 
    a[0][1] = a[1][1] = 0;
  }
  void set(int x, int y, int val = 1) {a[x][y] = val;}
} ;
mat bp(int x) {
  mat ans; ans.set(1, 1, -inf);
  ans.set(0, 0, g[x][0]); ans.set(0, 1, g[x][0]);
  ans.set(1, 0, g[x][1]); return ans;
}
mat mul(mat x, mat y) {
  mat ans; 
  for (int i = 0; i < 2; ++i) for (int j = 0; j < 2; ++j)
    for (int k = 0; k < 2; ++k)
      ans.a[i][j] = max(ans.a[i][j], x.a[i][k] + y.a[k][j]);
  return ans;
}
struct segt {
  struct node {
    int l, r;
    mat p;
  } t[N << 2];
  int lson(int x) {return x << 1;}
  int rson(int x) {return x << 1 | 1;}
  void pushup(int x) {t[x].p = mul(t[lson(x)].p, t[rson(x)].p);}
  void build(int x, int l, int r) {
    t[x].l = l; t[x].r = r;
    if (l == r) {
      t[x].p = bp(wt[l]);
      return ;
    } int mid = (l + r) >> 1;
    build(lson(x), l, mid);
    build(rson(x), mid + 1, r);
    pushup(x);
  }
  void update(int x, int pos) {
    if (t[x].l == t[x].r) {
      t[x].p = bp(wt[pos]);
      return ;
    } int mid = (t[x].l + t[x].r) >> 1;
    if (pos <= mid) update(lson(x), pos);
    else update(rson(x), pos);
    pushup(x);
  }
  node query(int x, int L, int R) {
    if (t[x].l >= L && t[x].r <= R)
      return t[x];
    int mid = (t[x].l + t[x].r) >> 1;
    if (L > mid) return query(rson(x), L, R);
    if (R <= mid) return query(lson(x), L, R);
    node ans, ls = query(lson(x), L, R), rs = query(rson(x), L, R);
    ans.l = ls.l; ans.r = rs.r;
    ans.p = mul(ls.p, rs.p);
    return ans;
  }
} t;
void update(int x, int val) {
  g[x][1] = g[x][1] - p[x] + val;
  p[x] = val; 
  while (x) {
    mat pre = t.query(1, dfn[top[x]], epos[top[x]]).p;
    t.update(1, dfn[x]);
    mat now = t.query(1, dfn[top[x]], epos[top[x]]).p;
    x = fa[top[x]];
    g[x][0] += max(now.a[0][0], now.a[1][0]) - max(pre.a[0][0], pre.a[1][0]);
    g[x][1] += now.a[0][0] - pre.a[0][0];
  }
}
signed main(void) {
  ios :: sync_with_stdio(false);
  cin.tie(0); cout.tie(0);
  cin >> n >> m;
  for (int i = 1; i <= n; ++i) cin >> p[i];
  for (int i = 1; i < n; ++i) {
    int u, v; cin >> u >> v;
    G[u].emplace_back(v);
    G[v].emplace_back(u);
  } dfs1(1); dfs2(1, 1);
  t.build(1, 1, n);
  for (int i = 1; i <= m; ++i) {
    int x, v; cin >> x >> v;
    update(x, v);
    mat p = t.query(1, 1, epos[1]).p;
    cout << max(p.a[0][0], p.a[1][0]) << '\n';
  }
  return 0;
}