10.5 T3 DDP BZOJ 4712

10.5 T3(bzoj 4712) 毒瘤DDP

题面：

(光看题面就知道有多毒瘤)

就是说让你从一个子树内选一些点，使得这些点能够把这个子树的所有叶子与子树的根分离开；

首先暴力很好想，也很好写，就是一个树形DP的式子，每次修改都\(DFS\)维护一遍， \(O(1)\)查询；

设\(f_x\)为以\(x\)为根的子树内的答案；

则有\(f_x=min(\sum f_{son}, val_x)\)

贴暴力代码：

void dfs(int x)//暴力 
{
    g[x] = 0;
    if(du[x] == 1&&x != 1) g[x] = 2e9;
    for(edge *i = head[x]; i; i = i->nxt)
    {
        if(i->to == fa[x]) continue;
        fa[i->to] = x;
        dfs(i->to);
    }
    for(edge *i = head[x]; i; i = i->nxt)
    {
        if(i->to == fa[x]) continue;
        g[x] += f[i->to];
    }
    f[x] = min(g[x], w[x]);
}

然后就考虑怎么优化，~~跑不了要根据这个式子的~~

考虑把这棵树链剖，剖完之后边就有了重链和轻边之分，点就有了重儿子轻儿子之分；

然后刚刚的式子就可变形

\(f(x) = min(g(x)+f(son), val(x))\)

其中\(f\)和上面一样 \(g(x)\)指所有轻儿子的\(f\)值之和，\(f_{son}\)是重儿子(其实就是把刚刚的\(\sum\)拆了)

扫描二维码关注公众号，回复： 7428898 查看本文章

然后看这个式子找矩阵

\[\begin{pmatrix}0&f_v\end{pmatrix}\] \(*\) \[\begin{pmatrix}0&val_x\\\infty&g_x\end{pmatrix}\] \(=\) \[\begin{pmatrix}0&f_x\end{pmatrix}\]

这里矩阵乘的定义需要改由以前的相乘之后求和改为相加之后取\(min\)(因为满足结合律a，看看式子也知道)

然后就知道\(f_{son}\)（重儿子）通过乘上父亲节点的矩阵就可以转移到\(f_x\)

考虑询问：对每一个节点都维护一个转移矩阵，询问某一个点时直接从叶子乘到那个点就是ta的答案

原因：1 每个点都在重链上

2 每个重链都有叶子节点

3 每个叶子节点转移矩阵是\((0, val_x)=(0 , f_x)\)

然后考虑怎么乘，（当然不是暴力乘啦）线段树啊，重链上是连续的DFS序，树剖基本操作啊

线段树上每个点也放矩阵不就行了吗，每次找答案的时候就从线段树上扒矩阵。。。。

考虑修改：

显然改一个点的话对ta的子树是没有影响的，只会对父亲及祖先有影响（其实跟这个也没啥关系，这是二分的做法，找第一个影响的点）

修改的话首先要在线段树上把它矩阵中的\(val\)改了，你会发现

1.对这条链上其他节点的矩阵是没有影响的（因为矩阵里存的\(val\)值和\(g\)值）所以它在本链上只是单点修改；

2. 它会对链顶的父亲的\(g\)产生影响,对链顶父亲也要单点修改；

3. 然后就是重复1.2直到根节点

4.考虑怎么修改链顶的父亲， ta的\(g\)是轻儿子的\(f\)组成的，现在你链顶的\(f\)已经改了。。

所以要在改之前把链顶\(f\)记录下来，让其减去旧的链顶\(f\)加上新的链顶\(f\) 即可

~~好像没了~~

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#define N 200005
#define int long long
using namespace std;
int read()
{
    register int x=0,f=1;register char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9')x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
    return x*f;
}
int n, w[N], m, g[N], fa[N], du[N], f[N];
int rk[N], id[N], size[N], dep[N], son[N], top[N], bot[N], dfn;
struct edge
{
    int to;
    edge *nxt;
    edge(int to, edge *nxt) : to(to), nxt(nxt) {}
} *head[N];
void add(int x, int y)
{
    head[x] = new edge(y, head[x]);
    du[x] ++;
}
void dfs(int x)//暴力 
{
    g[x] = 0;
    if(du[x] == 1&&x != 1) g[x] = 2e9;
    for(edge *i = head[x]; i; i = i->nxt)
    {
        if(i->to == fa[x]) continue;
        fa[i->to] = x;
        dfs(i->to);
    }
    for(edge *i = head[x]; i; i = i->nxt)
    {
        if(i->to == fa[x]) continue;
        g[x] += f[i->to];
    }
    f[x] = min(g[x], w[x]);
}
struct matrix 
{
    int v[3][3];
    friend matrix operator * (const matrix &a, const matrix &b)
    {
        matrix res;
        for(int i = 1; i <= 2; i ++)
        {
            for(int j = 1; j <= 2; j ++)
            {
                res.v[i][j] = 1e17;
                for(int k = 1; k <= 2; k ++)
                {
                    res.v[i][j] = min(res.v[i][j], a.v[i][k] + b.v[k][j]);
                }
            }
        }
        return  res;
    }
}a[N];
void dfs1(int x)
{
    size[x] = 1;
    for(edge *i = head[x]; i; i = i->nxt)
    {
        if(i->to == fa[x]) continue;
        fa[i->to] = x;
        dep[i->to] = dep[x] + 1;
        dfs1(i->to);
        size[x] += size[i->to];
        if(size[i->to] > size[son[x]]) son[x] = i->to;
    }
}
void dfs2(int x, int tp)
{
    rk[x] = ++dfn;
    id[dfn] = x; 
    top[x] = tp;
    bot[tp] = x;
    g[x] = 0;
    if(du[x] == 1&&x != 1) g[x] = 2e9;
    if(son[x])  dfs2(son[x], tp);
    for(edge *i = head[x]; i; i = i->nxt)
    {
        if(i->to == fa[x] || i->to == son[x]) continue;
        dfs2(i->to, i->to);
    }
    for(edge *i = head[x]; i ; i = i->nxt)
    {
        if(i->to == fa[x] || i->to == son[x]) continue;
        g[x] += f[i->to];
    }
    f[x] = min(w[x], g[x] + f[son[x]]);
}
struct Segment
{
    struct node
    {
         int l, r;
         matrix v;
         node *li, *ri;
         node(int l, int r) : l(l), r(r) {
            li = NULL, ri = NULL;
         }
         int mid() {
            return (l + r) >> 1;
         }
         void up() {
            v = ri->v * li->v;
        }
    }*root;
    
    void build(node *&k, int l, int r)
    {
        k = new node(l, r);
        if(l == r)
        {
            k->v = a[id[l]];
            return ;
        }
        build(k->li, l, k->mid());
        build(k->ri, k->mid()+1, r);
        k->up();
    }
    void change(node *k , int pos)
    {
        if(k->l == k->r) 
        {
            k->v = a[id[pos]];
            return ;
        }
        if(pos <= k->mid()) change(k->li, pos);
        else change(k->ri, pos);
        k->up();
    }
    matrix ask(node *k, int l, int r)
    {
        if(l == k->l &&r == k->r)
        {
            return k->v;
        }
        if(r <= k->mid())  return ask(k->li, l, r);
        else if(l >= k->mid() + 1) return ask(k->ri, l, r);
        else return ask(k->ri, k->mid()+1, r) * ask(k->li, l, k->mid());
    }   
}A;
int query(int x)
{
    return A.ask(A.root, rk[x], rk[bot[top[x]]]).v[1][2];//某点的f 
}
void update(int x)
{
    while(x) {
        a[x].v[1][2] = w[x];
        a[x].v[2][2] = g[x];//修改节点矩阵 
        A.change(A.root, rk[x]);//维护线段树 
        if(x == 1) break;
        x = top[x];
        g[fa[x]] -= f[x];//维护轻重链交替的地方 
        f[x] = A.ask(A.root, rk[x], rk[bot[top[x]]]).v[1][2];//找到那个地方的f值 
        g[fa[x]] += f[x];
        x = fa[x];//跳到上面的重链 
    }
}
signed main()
{
    freopen("c.in", "r", stdin);
    freopen("c.out", "w", stdout);
    n = read();
    for(int i = 1; i <= n; i ++)
       w[i] = read();
    for(int i = 1; i < n; i ++)
    {
        int x, y;
        x = read(); y = read();
        add(x, y);  add(y, x);
    }
    fa[1] = 0;
    dep[1] = 1;
    dfs1(1);
    dfs2(1, 1);
    for(int i = 1; i <= n; i ++)//叶子节点矩阵会赋成val 
    {
        a[i].v[1][1] = 0;
        a[i].v[1][2] = w[i];
        a[i].v[2][2] = g[i];
        a[i].v[2][1] = 1e17;
    }
    A.build(A.root, 1, n);
    m = read();
    char s[5];
    for(int i = 1, x, y; i <= m; i ++)
    {
        scanf("%s", s + 1);
        if(s[1] == 'Q') 
        {
            x = read();
            printf("%lld\n",query(x));
        }
        else
        {
            x = read(); y = read();
            w[x] += y;
            update(x);//单点修改 更新节点矩阵 
        }
    }   
    return 0;
}
/*
4
4 3 2 1
1 2
1 3
4 2
4
Q 1
Q 2
C 4 10
Q 1
*/

对于大部分ddp 来说

1.找出式子；

2.化成关于重儿子的式子；

3.推出矩阵，放线段树里

4.修改时跳链；

这是矩阵优化后的DDP可做的；

如果有那种修改没有可减性（就是你不能减去原来的再加上现在的，比如与，或运算），就要用原始的DDP做法，对每个节点重儿子开线段树轻儿子开线段树

10.5

T3(bzoj 4712) 毒瘤DDP

题面：