[BZOJ4446]-[Scoi2015]小凸玩密室-树形DP

说在前面

简直是，谜一样的树形DP….

---

题目

BZOJ4446传送门

题面

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

输入输出格式

输入格式：
第1行包含1个数N，代表节点的个数
第2行包含N个数，代表每个节点的权值ai。
第3行包含N-1个数，代表每条边的权值bi，第i号边是由第(i+1)/2号点连向第i+1号点的边。

输出格式：
输出一行一个整数，表示最小花费

---

解法

这DP的状态定义的十分巧妙。Doggu：感觉像拼图一样，一块一块的拼出了答案
题目告诉我们很多信息

1. 完全二叉树
2. 点亮的灯必须连续
3. 一个节点被点亮，则在整个子树点亮之前，不能去点亮其他节点
4. 点亮一个灯的代价，只与上一个被点亮的灯有关

可以发现，点亮灯的过程一定是形似这样的：
先点亮第一个灯u，然后把u的一个子树点亮，然后去点亮u的另一个子树。然后回到u的fa，点亮fa之后去点亮fa的另一个子树。然后回到fa的fa，点亮fa的fa之后去点亮另一个子树….

然而在这个点亮子树的过程中：
如果当前子树还没有被点亮，那么在点亮子树根，下一个点亮的点一定是它的儿子节点
而如果当前点亮的点是子树里最后一个点，那么下一个被点亮的点应该是它的某一级祖先，或者是祖先的另一个子树

那么于是定义dp数组：
fa[u][k]表示，当前u是亮的，从u出发，点亮u的子树之后回到 u的第k个祖先 的最小花费
br[u][k]表示，当前u是亮的，从u出发，点亮u的子树之后回到 u的第k个祖先的另一个儿子 的最小花费
转移不是很难，但是需要分情况讨论（叶子节点，只有一个儿子，有两个儿子）。

最后计算答案的时候，如果选择的点是1号点，那么答案就是fa[1][1]（这里假设1号节点也有父节点，不过权值为0），如果选择的不是1号点，根据点亮过程累加即可。

---

下面是自带大常数的代码

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std ;

const long long inf = ( 1LL << 62 ) ;
int N , A[200005] /*dis[][1] as B[]*/ , left[200005] , right[200005] ;
long long fa[200005][20] , br[200005][20] , dis[200005][20] , ans = inf ;

inline int another( int u , char i ){// another child for "1" is "0"
    return ( u >> ( i - 1 ) ) ^ 1 ;
}

void solve(){
    register char i ;
    register int u ;
    for( u = N ; u ; u -- )
        if( !left[u] ){//leaf 
            for( i = 1 ; u >> ( i - 1 ) ; i ++ )
                br[u][i] = ( dis[u][i] + dis[ another( u , i ) ][1] ) * A[ another( u , i ) ] ;
        } else if( !right[u] ){//single child
            for( i = 1 ; u >> ( i - 1 ) ; i ++ )
                br[u][i] = dis[ left[u] ][1] * A[ left[u] ] + br[ left[u] ][i+1] ;
        } else {//twins
            for( i = 1 ; u >> ( i - 1 ) ; i ++ )
                br[u][i] = min( dis[ left[u] ][1] * A[ left[u] ] + br[ left[u] ][1] + br[ right[u]][i+1] ,
                                dis[ right[u]][1] * A[ right[u]] + br[ right[u]][1] + br[ left[u] ][i+1] ) ;
        }

    for( u = N ; u ; u -- )
        if( !left[u] ){//leaf
            for( i = 1 ; u >> ( i - 1 ) ; i ++ )
                fa[u][i] = dis[u][i] * A[u>>i] ;
        } else if( !right[u] ){//single child
            for( i = 1 ; u >> ( i - 1 ) ; i ++ )
                fa[u][i] = dis[ left[u] ][1] * A[ left[u] ] + fa[ left[u] ][i+1] ;
        } else {//twins
            for( i = 1 ; u >> ( i - 1 ) ; i ++ )
                fa[u][i] = min( dis[ left[u] ][1] * A[ left[u] ] + br[ left[u] ][1] + fa[ right[u]][i+1] ,
                                dis[ right[u]][1] * A[ right[u]] + br[ right[u]][1] + fa[ left[u] ][i+1] ) ;
        }

    for( u = 1 ; u <= N ; u ++ ){
        long long nowans = fa[u][1] ;
        int tmp = u >> 1 , ano ;
        i = 1 ;
        while( tmp ){
            ano = another( u , i ) ;
            if( ano > N ) nowans += ( dis[tmp][1] * A[tmp>>1] ) ;
            else nowans += dis[ano][1] * A[ano] + fa[ano][2] ;
            i ++ ; tmp >>= 1 ;
        }
        ans = min( nowans , ans ) ;
    }
    printf( "%lld" , ans ) ;
}

int main(){
    scanf( "%d" , &N ) ;
    for( int i = 1 ; i <= N ; i ++ ) scanf( "%d" , &A[i] ) ;
    for( int i = 2 ; i <= N ; i ++ ) scanf( "%lld" , &dis[i][1] ) ;
    for( int u = 1 ; ; u ++ ){
        if( ( u << 1 ) <= N ) left[u] = ( u << 1 ) ;
        else break ;
        if( ( u << 1 ) + 1 <= N ) right[u] = ( u << 1 ) + 1 ;
    }
    for( char i = 2 ; i <= 18 ; i ++ )
        for( int u = N ; u >> i ; u -- )
            dis[u][i] = dis[u][i-1] + dis[u>>(i-1)][1] ;
    solve() ;
}