bzoj 4446: [Scoi2015]小凸玩密室

Time Limit: 10 Sec  Memory Limit: 128 MB
Submit: 115  Solved: 20
[Submit][Status][Discuss]

Description

小凸和小方相约玩密室逃脱，这个密室是一棵有n个节点的完全二叉树，每个节点有一个灯泡。点亮所有灯泡即可逃出密室。每个灯泡有个权值Ai，每条边有个权值bi。点亮第1个灯泡不需要花费，之后每点亮4个新的灯泡V的花费，等于上一个被点亮的灯泡U到这个点V的距离Du,v，乘以这个点的权值Av。在点灯的过程中，要保证任意时刻所有被点亮的灯泡必须连通，在点亮一个灯泡后必须先点亮其子树所有灯泡才能点亮其他灯泡。请告诉他们，逃出密室的最少花费是多少。

Input

第1行包含1个数n，代表节点的个数

第2行包含n个数，代表每个节点的权值ai。(i=l，2，…，n)

第3行包含n-l个数，代表每条边的权值bi，第i号边是由第(i+1)/2号点连向第i+l号点的边。

(i=l，2...N-1)

Output

输出包含1个数，代表最少的花费。

Sample Input

3
5 1 2
2 1

Sample Output

5

HINT

对于100%的数据，1≤N≤2×105，1<Ai,Bi≤10^5

题解：

　　a[x]表示x结点的权值；b[x]表示x结点到其父亲的边权；l[x]表示x的深度，令l[x]==1；d[x]表示x到根的距离；

　　f[x][y]表示走完x及其子树再走到y的最小代价。考虑转移方式，如果x是叶子节点，那么答案就是a[y]*distance(x,y)；如果x只有左孩子，就先遍历左子树，状态转移是a[lc]*b[lc]+f[lc][y]；如果两个孩子都有，就考虑是先转移到左孩子还是右孩子，f[x][y]=min(a[lc]*b[lc]+f[lc][rc]+f[rc][y],a[rc]*b[rc]+f[rc][lc]+f[lc][y])。

　　但是考虑到题目数据很大，这样的转移肯定在时间和空间上都不行。又发现有的x，y是不合法的，比如y肯定不能是x的子节点。由此考虑有意义的x，y，可以发现，如果x有一个祖先p(p包括x)，则y是p的兄弟节点，f[x][y]的含义变成了走完x及其子树到深度为y的节点的子节点的最小代价。

　　设g[x][i]表示走完x的子树再走到x的深度为i的祖先的最小代价。转移： 叶子：g[x][i]=a[y]*(d[x]-d[y]) 只有左孩子：g[x][i]=g[lc][i]+a[lc]*b[lc] 左右孩子都有：g[x][i]=min(a[lc]*b[lc]+f[lc][l[x]]+g[rc][i],a[rc]*b[rc]+f[rc][l[x]]+g[lc][i])。

　　最后就是统计答案了，我们选定一个节点x作为第一个点亮的灯，然后统计其子树的答案，再走到x的父节点，再走x的兄弟节点......以此类推。

　　由于f[][]和g[][]的第一维都是n，第二维都是logn，所以总的时间复杂度是O(nlogn)。

 

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
#include<vector>
using namespace std;
typedef long long LL;
const LL maxn=2*1e5+10;
LL N,a[maxn],b[maxn],d[maxn],l[maxn];
LL ANS,f[maxn][20],g[maxn][20];
int main(){
//    freopen("light.in","r",stdin);
//    freopen("light.out","w",stdout);
    scanf("%lld",&N);
    for(LL i=1;i<=N;i++) scanf("%lld",&a[i]);
    l[1]=1;
    for(LL i=2;i<=N;i++){
        scanf("%lld",&b[i]);
        l[i]=l[i>>1]+1; d[i]=d[i>>1]+b[i];
    }
    for(LL x=N,y,lc,rc,i;x;x--){
        for(LL i=0;i<l[x];i++){
            lc=2*x; rc=lc+1;
            y=(x>>(l[x]-i-1))^1;
            if(lc>N) f[x][i]=a[y]*(d[x]+d[y]-d[y>>1]*2);
            else if(rc>N) f[x][i]=a[lc]*b[lc]+f[lc][i];
            else f[x][i]=min(a[lc]*b[lc]+f[lc][l[x]]+f[rc][i],
                             a[rc]*b[rc]+f[rc][l[x]]+f[lc][i]);
        }
    }
    for(LL x=N,y,lc,rc,i;x;x--){
        for(LL i=0;i<=l[x];i++){
            lc=2*x; rc=lc+1;
            y=x>>(l[x]-i);
            if(lc>N) g[x][i]=a[y]*(d[x]-d[y]);
            else if(rc>N) g[x][i]=g[lc][i]+a[lc]*b[lc];
            else g[x][i]=min(a[lc]*b[lc]+f[lc][l[lc]-1]+g[rc][i],
                             a[rc]*b[rc]+f[rc][l[rc]-1]+g[lc][i]);//f[lc][l[lc]-1]表示结点走完lc及子树再走到rc的最小代价 
        }
    }
    ANS=g[1][0];
    for(LL i=2;i<=N;i++){
        LL res=g[i][l[i]-1]; LL tmp=i;
        for(LL y,z;tmp!=1;tmp>>=1){
            y=tmp^1; z=tmp>>1;
            if(y>N) res+=a[z>>1]*b[z];
            else res+=a[y]*b[y]+g[y][l[z]-1];
        }
        ANS=min(ANS,res);
    }
    printf("%lld",ANS);
    return 0;
}