[NOIP2018 提高组] 保卫王国

[NOIP2018 提高组] 保卫王国

Luogu传送门

本文大量参考：题解 P5024 【保卫王国】 - Shallowy 的博客

Description

Z 国有 \(n\) 座城市，\((n - 1)\) 条双向道路，每条双向道路连接两座城市，且任意两座城市都能通过若干条道路相互到达。

Z 国的国防部长小 Z 要在城市中驻扎军队。驻扎军队需要满足如下几个条件：

• 一座城市可以驻扎一支军队，也可以不驻扎军队。
• 由道路直接连接的两座城市中至少要有一座城市驻扎军队。
• 在城市里驻扎军队会产生花费，在编号为 \(i\) 的城市中驻扎军队的花费是 \(p_i\).

小 Z 很快就规划出了一种驻扎军队的方案，使总花费最小。但是国王又给小 Z 提出了 \(m\) 个要求，每个要求规定了其中两座城市是否驻扎军队。小 Z 需要针对每个要求逐一给出回答。具体而言，如果国王提出的第 \(j\) 个要求能够满足上述驻扎条件（不需要考虑第 \(j\) 个要求之外的其它要求），则需要给出在此要求前提下驻扎军队的最小开销。如果国王提出的第 \(j\) 个要求无法满足，则需要输出 \(-1\)。现在请你来帮助小 Z。

Input format

第一行有两个整数和一个字符串，依次表示城市数 \(n\)，要求数 \(m\) 和数据类型 \(type\)。\(type\) 是一个由大写字母 A，B 或 C 和一个数字 1，2，3 组成的字符串。它可以帮助你获得部分分。你可能不需要用到这个参数。这个参数的含义在【数据规模与约定】中 有具体的描述。

第二行有 \(n\) 个整数，第 \(i\) 个整数表示编号 \(i\) 的城市中驻扎军队的花费 \(p_i\)。

接下来 \((n - 1)\) 行，每行两个整数 \(u,v\)，表示有一条 \(u\) 到 \(v\) 的双向道路。

接下来 \(m\) 行，每行四个整数 \(a, x, b, y\)，表示一个要求是在城市 \(a\) 驻扎 \(x\) 支军队，在城市 \(b\) 驻扎 \(y\) 支军队。其中，\(x,y\) 的取值只有 \(0\) 或 \(1\)

• 若 \(x\) 为 \(0\)，表示城市 \(a\) 不得驻扎军队。
• 若 \(x\) 为 \(1\)，表示城市 \(a\) 必须驻扎军队。
• 若 \(y\) 为 \(0\)，表示城市 \(b\) 不得驻扎军队。
• 若 \(y\) 为 \(1\)，表示城市 \(b\) 必须驻扎军队。

输入文件中每一行相邻的两个数据之间均用一个空格分隔。

Output format

输出共 \(m\) 行，每行包含一个个整数，第 \(j\) 行表示在满足国王第 \(j\) 个要求时的最小开销， 如果无法满足国王的第 \(j\) 个要求，则该行输出 \(-1\)。

Examples

Input:

5 3 C3 
2 4 1 3 9 
1 5 
5 2 
5 3 
3 4 
1 0 3 0 
2 1 3 1 
1 0 5 0

Output:

12 
7 
-1

Tips

Explanation of example 1

• 对于第一个要求，在 \(4\) 号和 \(5\) 号城市驻扎军队时开销最小。
• 对于第二个要求，在 \(1\) 号、\(2\) 号、\(3\) 号城市驻扎军队时开销最小。
• 第三个要求是无法满足的，因为在 \(1\) 号、\(5\) 号城市都不驻扎军队就意味着由道路直接连接的两座城市中都没有驻扎军队。

Data scale and agreement

略
数据类型的含义：

• A：城市 \(i\) 与城市 \(i + 1\) 直接相连。
• B：任意城市与城市 \(1\) 的距离不超过 \(100\)（距离定义为最短路径上边的数量），即如果这 棵树以 \(1\) 号城市为根，深度不超过 \(100\)。
• C：在树的形态上无特殊约束。
• 1：询问时保证 \(a = 1,x = 1\) 即要求在城市 \(1\) 驻军。对 \(b,y\) 没有限制。
• 2：询问时保证 \(a,b\) 是相邻的（由一条道路直接连通）
• 3：在询问上无特殊约束。

对于 \(100\%\) 的数据，保证 \(1 \leq n,m ≤ 10^5\)，\(1 ≤ p_i ≤ 10^5\)，\(1 \leq u, v, a, b \leq n\)，\(a \neq b\)，\(x, y \in \{0, 1\}\)。

Analysis

（成功地通过题面水了一波字数）

Explain

我们首先可以简要地概括题意：

有棵树，可以花 \(p_i\) 代价把 \(i\) 点染色，要求任2个相邻点至少有1个被染色。给出 \(m\) 组询问，每次强制两个点的状态(染/不染)，求出每次的最小花费。

BF

44分暴力算法应该是显然的。

假如我们忽略掉 \(m\) 组询问所带来的额外约束，那么就是一个简单的树形 DP

给定一棵树，现在从中选出最少的点，使得所以边至少有一个端点再选中的集合中。

我们可以考虑每个点选或者不选。

状态 \(dp[0][u],dp[1][u]\) 表示点 \(u\) 不选或选，以 \(u\) 为根的子树的最小结点数。那么显然有：

• \(dp[0][u]=\sum dp[1][v]\)
• \(dp[1][u]=\sum \min(dp[0][v],dp[1][v])+p_i\)

其中 \(v\) 为 \(u\) 的孩子节点，这样是 \(O(n)\) 的。

然后枚举每一个约束，通过赋值 \(inf\) 的方式就可以强制 \(u\) 选/不选，跑 \(m\) 遍即可。

所以复杂度 \(O(nm)\) \(44pts\)

Solution

现在进入正解。

经过前面的暴力，很容易发现，其不优秀之处在于每次都把以前算过的干掉并重新 \(O(n)\) 算了一遍。我们考虑优化。

注意到每次约束的点只有两个，显然，修改点只会对图中加红部分有影响：

而对于其他部分的贡献，可以用我们第一次 DP 时求出的值直接代入。

现在问题变成了如何求这几条链上的答案，注意 \(u,v\) 到 \(lca\) 的路径中可能接有多颗子树。

那么，我们需要知道对于一个点 \(u\) ，\(dp[0/1][ u 的任意祖先]u对此状态的贡献\)

这个应该是很好理解的，因为 \(u\) 的贡献是不一定的。

所以，设 \(f[0/1][0/1][anc][u]\) 表示在整个祖先 \(ans\) 的树中减去 \(u\) 的子树的影响的值，第一维表示 \(u\) 选/不选，第二维表示 \(anc\) 选/不选

也就是图中红色部分的值：

图源：@洛谷 Shallowy

显然，在求得这个数组后，（见第一张图）我们可以直接把 \(u,v\) 到 \(lca\) 的路径上的 \(f\) 数组加起来，并加上 \(u\) 的子树的 \(dp\) 值和 \(v\) 的子树的 \(dp\) 值，添上图中 \(lca\) 其他子树的贡献，再从 \(lca\) 开始加 \(f\) 到根节点，以及加上图中根节点其他子树的贡献，就能算出总费用。

——分割线——

所以现在的问题是如何快速预处理出 \(f\)

细心的您一定注意到了，按我们之前对于 \(f\) 的定义，是要爆空间的 （\(4*n^2\)），况且时间也抗不住（可以尝试写写）

不妨从最开始分析：

假设第二张图中的 \(father\) 是 \(u\) 的直接父亲,显然有

• \(f[0][0][0][u]=inf\)

• \(f[1][0][0][u]=dp[0][father]-dp[1][u]\)

• \(f[0][1][0][u]=f[1][1][0][u]=dp[1][father]-\min(dp[0][u],dp[1][u]);\)

我们想推知 \(f[0/1][0/1][1][u]\) ，显然可以利用以求出的 \(f[0/1][0/1][0][father]\)

• \(f[0][0][i][u]=Min(f[0][0][i-1][u]+f[0][0][i-1][father],f[0][1][i-1][u]+f[1][0][i-1][father]);\)
• \(f[0][1][i][u]=Min(f[0][0][i-1][u]+f[0][1][i-1][father],f[0][1][i-1][u]+f[1][1][i-1][father]);\)
• \(f[1][0][i][u]=Min(f[1][0][i-1][u]+f[0][0][i-1][father],f[1][1][i-1][u]+f[1][0][i-1][father]);\)
• \(f[1][1][i][u]=Min(f[1][0][i-1][u]+f[0][1][i-1][father],f[1][1][i-1][u]+f[1][1][i-1][father]);\)

如图：

联系到 \(lca\) --> 倍增，正确性是显然的。

所以，我们可以换一种方式定义 \(f\) ：

设 \(f[0/1][0/1][i][u]\) 表示 \(u\) 不选/选，\(u\) 往上跳 \(2^i\) 步的祖先不选/选时，从 \(u\) 开始(不包括 \(u\) )\(dp\) 到 \(u\) 往上跳 \(2^i\) 步的祖先 且计入其他子树的最终 \(dp\) 值。即在整个祖先的子树中减去 \(u\) 的子树的影响。

上述 \(f\) 更新方式略做修改即可。

Special

有一些特殊情况：

• 当 \(u,v\) 在一条链上时，倍增 \(u\) 之后已经在 \(lca\) 上了，此时直接倍增 \(lca\) 即可
• 当 \(lca\) 为根节点时，显然不需要倍增 \(lca\)，此时直接算出总答案。

Process

总结一下整个算法流程：

1.DFS 预处理 \(dp\) 数组和 \(f\) 数组(倍增数组);

对于询问：

2.将深度大的点 \(u\) 往 \(v\) 的深度跳（类似倍增 \(lca\)） 同时更新新的 \(dp\) 值；

3.\(u,v\) 同时往上跳至 \(lca\) 的儿子处同时更新新的 \(dp\) 值；

4.得到 \(lca\) 的 \(dp\) 值，再往上跳至根节点的儿子处同时更新新的 \(dp\) 值；

5.讨论根节点的状态得出最终答案。(特殊情况见上)

Code

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5+5;
const ll inf = 1e14;
int pw[]={1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072};

struct Edge{
    int nex,to;
}edge[N<<1];
int head[N],p[N],fath[19][N],dep[N],Log[N];
ll dp[2][N],f[2][2][19][N];
int n,m,elen,u,x,v,y;
char ch[5];

void add(int from,int to){
    edge[++elen]={head[from],to};
    head[from]=elen;
}
void Dp(int u){
    dep[u]=dep[fath[0][u]]+1;
    dp[1][u]=p[u];f[0][0][0][u]=inf;
    for(int i=1;pw[i]<dep[u];i++)fath[i][u]=fath[i-1][fath[i-1][u]];
    for(int e=head[u],v;e;e=edge[e].nex){
        if((v=edge[e].to)==fath[0][u])continue;
        fath[0][v]=u;Dp(v);
        dp[0][u]+=dp[1][v];
        dp[1][u]+=min(dp[0][v],dp[1][v]); 
    }
}
void Dfs(int u){
    f[1][0][0][u]=dp[0][fath[0][u]]-dp[1][u];
    f[0][1][0][u]=f[1][1][0][u]=dp[1][fath[0][u]]-min(dp[0][u],dp[1][u]);
    for(int i=1;pw[i]<dep[u];i++){
        int F=fath[i-1][u];
        f[0][0][i][u]=min(f[0][0][i-1][u]+f[0][0][i-1][F],f[0][1][i-1][u]+f[1][0][i-1][F]);
        f[0][1][i][u]=min(f[0][0][i-1][u]+f[0][1][i-1][F],f[0][1][i-1][u]+f[1][1][i-1][F]);
        f[1][0][i][u]=min(f[1][0][i-1][u]+f[0][0][i-1][F],f[1][1][i-1][u]+f[1][0][i-1][F]);
        f[1][1][i][u]=min(f[1][0][i-1][u]+f[0][1][i-1][F],f[1][1][i-1][u]+f[1][1][i-1][F]);
    }
    for(int e=head[u],v;e;e=edge[e].nex)if((v=edge[e].to)!=fath[0][u])Dfs(v);
}
void Exlca(){
    if(dep[u]<dep[v])swap(x,y),swap(u,v);
    ll u0,u1,v0,v1,l0,l1,ans;u0=u1=v0=v1=l0=l1=inf;int L;
    x?u1=dp[1][u]:u0=dp[0][u];y?v1=dp[1][v]:v0=dp[0][v];
    for(int i=Log[dep[u]-dep[v]];i>=0;i--)if(dep[u]-pw[i]>=dep[v]){
        ll t0=u0,t1=u1;
        u0=min(t0+f[0][0][i][u],t1+f[1][0][i][u]);
        u1=min(t0+f[0][1][i][u],t1+f[1][1][i][u]);
        u=fath[i][u];
    }
    if(u==v)L=u,y?l1=u1:l0=u0;
    else{
        for(int i=Log[dep[u]-1];i>=0;i--)if(fath[i][u]!=fath[i][v]){
            ll t0=u0,t1=u1,p0=v0,p1=v1;
            u0=min(t0+f[0][0][i][u],t1+f[1][0][i][u]);
            u1=min(t0+f[0][1][i][u],t1+f[1][1][i][u]);
            v0=min(p0+f[0][0][i][v],p1+f[1][0][i][v]);
            v1=min(p0+f[0][1][i][v],p1+f[1][1][i][v]);
            u=fath[i][u];v=fath[i][v];
        }
        L=fath[0][u];l0=dp[0][L]-dp[1][u]-dp[1][v]+u1+v1;
        l1=dp[1][L]-min(dp[0][u],dp[1][u])-min(dp[0][v],dp[1][v])+min(u0,u1)+min(v0,v1);
    }
    if(L==1)ans=min(l0,l1);
    else{
        for(int i=Log[dep[L]-2];i>=0;i--)if(dep[L]-pw[i]>1){
            ll t0=l0,t1=l1;
            l0=min(t0+f[0][0][i][L],t1+f[1][0][i][L]),
            l1=min(t0+f[0][1][i][L],t1+f[1][1][i][L]),
            L=fath[i][L];
        }
        ans=min(dp[0][1]-dp[1][L]+l1,dp[1][1]-min(dp[0][L],dp[1][L])+min(l0,l1));
    }
    if(ans<inf)puts("-1");
    else printf("%lld\n",ans);
}

int main(){
    scanf("%d%d%s",&n,&m,ch);
    for(int i=1;i<=n;i++)scanf("%d",&p[i]);
    for(int i=2;i<=n;i++){
        scanf("%d%d",&u,&v);
        add(u,v);add(v,u);
        Log[i]=Log[i>>1]+1;
    }
    Dp(1);Dfs(1);
    while(m--){
        scanf("%d%d%d%d",&u,&x,&v,&y);
        Exlca();
    }
    return 0;
}

Solution 2

DDP 裸题，实现注意细节

//wyb 绝不摆烂！！！
#include<bits/stdc++.h>
#define int long long
#define ls rt<<1
#define rs rt<<1|1
#define mid ((l+r)>>1)
using namespace std;
const int N = 1e5+5;

char buf[1<<23],*p1=buf,*p2=buf;
#define getchar() (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<21,stdin),p1==p2)?EOF:*p1++)
int read(){
    int s=0,w=1; char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')w=-1; ch=getchar();}
    while(isdigit(ch))s=s*10+(ch^48),ch=getchar();
    return s*w;
}
void file(){
    freopen("defense.in","r",stdin);
    freopen("defense.out","w",stdout);
}

struct Matrix{
    int a[2][2];
    Matrix(){
        a[0][0]=a[0][1]=1e11;
        a[1][0]=a[1][1]=1e11;
    }
    Matrix(int g0,int g1){
        a[0][0]=1e11,a[1][0]=g0;
        a[0][1]=a[1][1]=g1;
    }
    Matrix operator*(const Matrix&rhs)const{
        Matrix res;
        for(int i=0;i<2;++i)for(int j=0;j<2;++j)for(int k=0;k<2;++k)
            res.a[i][j]=min(res.a[i][j],a[i][k]+rhs.a[k][j]);
        return res;
    }
    void print(){
        for(int i=0;i<2;++i,puts(""))
            for(int j=0;j<2;++j)
                cout<<a[i][j]<<" ";
        // puts("");
    }
}t[N<<2],dp[N],g[N],tmp[N],one;
int c[N],siz[N],dep[N],f[N],son[N],bot[N],top[N],dfn[N],rev[N];
vector<int>Edge[N];
int n,m,tim;


void dfs1(int u){
    for(auto v:Edge[u])if(v^f[u])
        dep[v]=dep[f[v]=u]+(siz[v]=1),dfs1(v),
        siz[u]+=siz[v],(siz[v]>siz[son[u]]&&(son[u]=v,1));
}
void dfs2(int u,int tp){
    top[u]=tp,dfn[u]=++tim,rev[tim]=u,bot[u]=u;
    if(son[u])dfs2(son[u],tp),bot[u]=bot[son[u]];
    for(auto v:Edge[u])if(v^f[u]&&v^son[u])dfs2(v,v);
}
void dfs(int u){
    dp[u].a[0][0]=g[u].a[0][0]=0;
    dp[u].a[0][1]=g[u].a[0][1]=c[u];
    if(son[u])
        dfs(son[u]),
        dp[u].a[0][0]+=dp[son[u]].a[0][1],
        dp[u].a[0][1]+=min(dp[son[u]].a[0][0],dp[son[u]].a[0][1]);
    for(auto v:Edge[u])if(v^f[u]&&v^son[u])
        dfs(v),
        dp[u].a[0][0]+=dp[v].a[0][1],
        g[u].a[0][0]+=dp[v].a[0][1],
        dp[u].a[0][1]+=min(dp[v].a[0][0],dp[v].a[0][1]),
        g[u].a[0][1]+=min(dp[v].a[0][0],dp[v].a[0][1]);
}

void pushup(int rt){t[rt]=t[rs]*t[ls];}///////
void build(int l,int r,int rt){
    if(l==r)return t[rt]=Matrix(g[rev[l]].a[0][0],g[rev[l]].a[0][1]),void();
    build(l,mid,ls),build(mid+1,r,rs),pushup(rt);
}
void alter(int l,int r,int rt,int id,Matrix v){
    if(l==r)return t[rt]=v,void();
    id<=mid?alter(l,mid,ls,id,v):alter(mid+1,r,rs,id,v);
    pushup(rt);
}
Matrix query(int l,int r,int rt,int L,int R){
    if(L>R)return one;
    if(L<=l&&r<=R)return t[rt];
    if(R<=mid)return query(l,mid,ls,L,R);
    if(mid<L)return query(mid+1,r,rs,L,R);
    return query(mid+1,r,rs,L,R)*query(l,mid,ls,L,R);
}

void change(int u,bool x){
    Matrix nw=query(1,n,1,dfn[u],dfn[u]);
    if(tmp[u].a[0][0]==1e11&&tmp[u].a[0][1]==1e11)tmp[u]=dp[u];

    Matrix temp=dp[u];
    if(x)nw.a[1][0]=dp[u].a[0][0]=1e11;
    else nw.a[0][1]=nw.a[1][1]=dp[u].a[0][1]=1e11;

    // cout<<u<<" "<<top[u]<<endl;
    // int _=u;
    while(top[u]!=1){
        int nex=f[top[u]];
        Matrix bef=(u==bot[u]?temp:dp[bot[u]])*query(1,n,1,dfn[top[u]],dfn[bot[u]]-1);
        alter(1,n,1,dfn[u],nw);
        // cout<<u<<endl;
        Matrix now=dp[bot[u]]*query(1,n,1,dfn[top[u]],dfn[bot[u]]-1);
        Matrix ori=query(1,n,1,dfn[nex],dfn[nex]);
        // if(top[u]==bot[u])bef=temp;
        // if(u==5)bef.print(),now.print(),ori.print(),puts("");
        int g0=ori.a[1][0]+now.a[0][1]-bef.a[0][1];
        int g1=ori.a[0][1]+min(now.a[0][0],now.a[0][1])-min(bef.a[0][0],bef.a[0][1]);
        // cout<<nex<<" "<<g0<<" "<<g1<<endl;
        if(tmp[nex].a[0][0]==1e11&&tmp[nex].a[0][1]==1e11)tmp[nex]=dp[nex];
        temp=dp[nex],dp[nex].a[0][0]=g0,dp[nex].a[0][1]=g1;
        nw=Matrix(g0,g1);
        u=nex;
    }
    alter(1,n,1,dfn[u],nw);
    // cout<<u<<endl;
}
void recover(int u){
    // if(u==5)tmp[5].print();
    if(tmp[u].a[0][0]!=1e11||tmp[u].a[0][1]!=1e11)
        dp[u]=tmp[u],tmp[u].a[0][0]=tmp[u].a[0][1]=1e11;
    while(top[u]!=1){
        int nex=f[top[u]];
        alter(1,n,1,dfn[u],Matrix(g[u].a[0][0],g[u].a[0][1]));//ori:u->nex
        if(tmp[nex].a[0][0]!=1e11||tmp[nex].a[0][1]!=1e11)
            dp[nex]=tmp[nex],tmp[nex].a[0][0]=tmp[nex].a[0][1]=1e11;
        u=nex;
    }
    alter(1,n,1,dfn[u],Matrix(g[u].a[0][0],g[u].a[0][1]));
}

signed main(){
    freopen("P5024_3.in","r",stdin);
    one.a[0][0]=one.a[1][1]=0;
    n=read(),m=read(),getchar(),getchar();
    for(int i=1;i<=n;++i)c[i]=read();
    for(int i=1,u,v;i<n;++i)
        u=read(),v=read(),
        Edge[u].push_back(v),
        Edge[v].push_back(u);
    dfs1(siz[1]=1),dfs2(1,1),dfs(1),build(1,n,1);

    // for(int i=1;i<=n;++i)printf("%d:%d %d %d\n",i,dep[i],siz[i],top[i]);
    // for(int i=1;i<=n;++i)printf("%d:\n",i),g[i].print();
    // for(int i=1;i<=n;++i)query(1,n,1,dfn[i],dfn[i]).print();
    // Matrix t=query(1,n,1,2,3); t.print();
    // Matrix test=query(1,n,1,dfn[1],dfn[bot[1]]-1); test.print();
    // Matrix now=dp[bot[1]]*query(1,n,1,dfn[1],dfn[bot[1]]-1);
    // printf("%lld\n",min(now.a[0][0],now.a[0][1]));

    for(int i=1,a,x,b,y;i<=m;++i){
        a=read(),x=read(),b=read(),y=read();
        // for(int j=1;j<=n;++j)query(1,n,1,dfn[j],dfn[j]).print();puts("");
        change(a,x);
        // for(int j=1;j<=n;++j)query(1,n,1,dfn[j],dfn[j]).print();puts("");
        change(b,y);
        // for(int j=1;j<=n;++j)query(1,n,1,dfn[j],dfn[j]).print();puts("");
        // for(int j=1;j<n;++j)(dp[n]*query(1,n,1,j,n-1)).print();puts("");
        Matrix now=dp[bot[1]]*query(1,n,1,dfn[1],dfn[bot[1]]-1);
        int ans=min(now.a[0][0],now.a[0][1]);
        if(ans>=1e11)puts("-1");
        else printf("%lld\n",ans);
        // tmp[5].print();
        // cout<<a<<" "<<b<<endl;
        recover(a),recover(b);
        // for(int j=1;j<=n;++j)query(1,n,1,dfn[j],dfn[j]).print();puts("");
    }
    // for(int i=1;i<=n;++i)query(1,n,1,dfn[i],dfn[i]).print();
    return 0;
}

/*
5 1 C3 
2 4 1 3 9 
1 5 
5 2 
5 3 
3 4 
2 1 3 1 
*/