【洛谷】P4643 【模板】动态dp

题解

在冬令营上听到冬眠的东西，现在都是板子了猫锟真的是好毒瘤啊(雾)

(立个flag，我去thusc之前要把WC2018T1乱搞过去= =）

好的，我们可以参考猫锟的动态动态dp的课件，然后你发现你什么都看不懂（菜啊

但是我们仔细看一看，可以发现用数据结构维护矩阵，那么我们尝试构造一个矩阵

\(\begin{bmatrix} \ g_{u,0} & g_{u,0}\\ g_{u,1} & 0 \end{bmatrix} \begin{bmatrix} f_{son[u],0}\\ f_{son[u],1} \end{bmatrix} = \begin{bmatrix} f_{u,0}\\ f_{u,1} \end{bmatrix}\)
其中\(g_{u,0}\)表示不选u，对于u的子树，除了u的重儿子所在子树，u的轻儿子最大独立集是多少
\(g_{u,1}\)表示选了u
\(f_{u,0}\)表示不选u，以u为根的子树最大独立集是多少
\(f_{u,1}\)表示选了u，以u为根的子树最大独立集是多少

这个矩阵的运算不是加法和乘法，而是加法和取max
也就是\(c_{i,j} = max(a_{i,k} + b_{k,j})\)
也是满足结合律的

这样我们就可以用一个树链剖分来维护这些矩阵了

注意一下，合并矩阵的时候是左右合并，但是乘法的时候一定先从右边乘
举个例子，我们的运算实际是这样的
一条链:
3 - 4 - 5
3是4的父亲，4是5的父亲
\(\begin{bmatrix} \ g_{3,0} & g_{3,0}\\ g_{3,1} & 0 \end{bmatrix} \begin{bmatrix} \ g_{4,0} & g_{4,0}\\ g_{4,1} & 0 \end{bmatrix} \begin{bmatrix} f_{5,0}\\ f_{5,1} \end{bmatrix} = \begin{bmatrix} f_{3,0}\\ f_{3,1} \end{bmatrix}\)
也就是5先和4的矩阵结合，再和3的矩阵结合

实际上写代码的时候，既然每一条链的最后一定是一个叶子节点，我们就可以直接把f0设成0，f1设成0去做矩阵乘法，乘上这条链上所有的矩阵作为链顶的f值

代码

#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <map>
//#define ivorysi
#define pb push_back
#define space putchar(' ')
#define enter putchar('\n')
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define mo 974711
#define RG register
#define MAXN 100005
#define debug
using namespace std;
typedef long long int64;
typedef double db;
template<class T>
void read(T &res) {
    res = 0;char c = getchar();T f = 1;
    while(c < '0' || c > '9') {
    if(c == '-') f = -1;
    c = getchar();
    }
    while(c >= '0' && c <= '9') {
    res = res * 10 + c - '0';
    c = getchar();
    }
    res *= f;
}
template<class T>
void out(T x) {
    if(x < 0) putchar('-'),x = -x;
    if(x >= 10) out(x / 10);
    putchar('0' + x % 10);
}
const int MOD = 1000000007;
int mul(int a,int b) {
    return 1LL * a * b % MOD;
}
int inc(int a,int b) {
    a = a + b;
    if(a >= MOD) a -= MOD;
    return a;
}

int fpow(int x,int c) {
    int res = 1,t = x % MOD;
    while(c) {
    if(c & 1) res = mul(res,t);
    t = mul(t,t);
    c >>= 1;
    }
    return res;
}
int N,Q;
int64 val[MAXN],g[MAXN][2],f[MAXN][2];
int top[MAXN],btm[MAXN],dfn[MAXN],fa[MAXN],dep[MAXN],son[MAXN],idx,siz[MAXN],L[MAXN],pos[MAXN];
int cnt = 0;
struct node {
    int to,next;
}E[MAXN * 2];
int head[MAXN],sumE;
struct tr_node {
    int l,r;
    int64 M[2][2];
}tr[MAXN * 4];
void add(int u,int v) {
    E[++sumE].to = v;
    E[sumE].next = head[u];
    head[u] = sumE;
}
void dfs1(int u) {
    dep[u] = dep[fa[u]] + 1;
    siz[u] = 1;
    for(int i = head[u] ; i ; i = E[i].next) {
    int v = E[i].to;
    if(v != fa[u]) {
        fa[v] = u;
        dfs1(v);
        siz[u] += siz[v];
        if(siz[v] > siz[son[u]]) son[u] = v;
    }
    }
}
void dfs2(int u) {
    dfn[u] = ++idx;
    L[idx] = u;
    if(!top[u]) {top[u] = u;}
    if(son[u]) {
    top[son[u]] = top[u];
    dfs2(son[u]);
    btm[u] = btm[son[u]]; 
    }
    g[u][1] = val[u];g[u][0] = 0;
    for(int i = head[u] ; i ; i = E[i].next) {
    int v = E[i].to;
    if(v != son[u] && v != fa[u]) {
        dfs2(v);
        g[u][0] += max(f[v][0],f[v][1]);
        g[u][1] += max(0LL,f[v][0]);
    }
    }
    f[u][1] = g[u][1] + max(f[son[u]][0],0LL);
    f[u][0] = g[u][0] + max(f[son[u]][1],f[son[u]][0]);
    if(!son[u]) btm[u] = u;
}
void update(int u) {
    int L = u << 1,R = u << 1 | 1;
    tr[u].M[0][0] = max(tr[L].M[0][0] + tr[R].M[0][0],tr[L].M[0][1] + tr[R].M[1][0]);
    tr[u].M[0][1] = max(tr[L].M[0][0] + tr[R].M[0][1],tr[L].M[0][1] + tr[R].M[1][1]);
    tr[u].M[1][0] = max(tr[L].M[1][0] + tr[R].M[0][0],tr[L].M[1][1] + tr[R].M[1][0]);
    tr[u].M[1][1] = max(tr[L].M[1][0] + tr[R].M[0][1],tr[L].M[1][1] + tr[R].M[1][1]);
}
void build(int u,int l,int r) {
    tr[u].l = l;tr[u].r = r;
    if(l == r) {
    int v = L[l];
    tr[u].M[0][0] = g[v][0];tr[u].M[0][1] = g[v][0];
    tr[u].M[1][0] = g[v][1];tr[u].M[1][1] = 0;
    pos[v] = u;
    return ;
    }
    int mid = (l + r) >> 1;
    build(u << 1,l,mid);build(u << 1 | 1,mid + 1,r);
    update(u);
}
void Query(int u,int L,int R,int64 &f0,int64 &f1) {
    if(tr[u].l == L && tr[u].r == R) {
    int64 x = max(f0 + tr[u].M[0][0],f1 + tr[u].M[0][1]);
    int64 y = max(f0 + tr[u].M[1][0],f1 + tr[u].M[1][1]);
    f0 = x;f1 = y;
    return;
    }
    int mid = (tr[u].l + tr[u].r) >> 1;
    if(R <= mid) Query(u << 1,L,R,f0,f1);
    else if(L > mid) Query(u << 1 | 1,L,R,f0,f1);
    else {
    Query(u << 1 | 1,mid + 1,R,f0,f1);
    Query(u << 1,L,mid,f0,f1);
    }
}
void Change(int x) {
    int t = pos[x] >> 1;
    while(t) {
    update(t);
    t >>= 1;
    }
}
void Change_tr(int x) {
    while(1) {
    int a = top[x];
    if(fa[a] != 0) {
        g[fa[a]][0] -= max(f[a][0],f[a][1]);
        g[fa[a]][1] -= max(f[a][0],0LL);
    }
    f[a][0] = 0;f[a][1] = 0;
    Query(1,dfn[top[x]],dfn[btm[x]],f[a][0],f[a][1]);
    if(fa[a] == 0) break;
    g[fa[a]][0] += max(f[a][0],f[a][1]);
    g[fa[a]][1] += max(f[a][0],0LL);
    x = fa[a];
    tr[pos[x]].M[0][0] = tr[pos[x]].M[0][1] = g[x][0];
    tr[pos[x]].M[1][0] = g[x][1];tr[pos[x]].M[1][1] = 0;
    Change(x);
    }
}
void Init() {
    read(N);read(Q);
    for(int i = 1 ; i <= N ; ++i) read(val[i]);
    int u,v;
    for(int i = 1 ; i < N ; ++i) {
    read(u);read(v);
    add(u,v);add(v,u);
    }
    dfs1(1);
    dfs2(1);
    build(1,1,N);
}
void Solve() {
    int x;int64 y;
    
    while(Q--) {
    ++cnt;
    read(x);read(y);
    g[x][1] = g[x][1] - val[x] + y;
    tr[pos[x]].M[1][0] = g[x][1];
    val[x] = y;
    Change(x);
    Change_tr(x);
    out(max(f[1][0],f[1][1]));enter;
    
    }
}
int main() {
#ifdef ivorysi
    freopen("f1.in","r",stdin);
#endif
    Init();
    Solve();
    return 0;
}