[树形dp] 选课(多叉树解) & 通向自由的钥匙(转二叉树解)

题目描述及提交：http://www.tyvj.cn:8080/Problem_Show.asp?id=1051

 

这是一道典型的树形动态规划，被教程资料当做例子引用了很多。

 

网上普遍的解法是转换成二叉树来解。但是我对第一儿子+兄弟的树表示法情有独钟，所以打算用多叉树来解。

 

最开始的状态表示是:F[i][j]表示以i为根的树中选j门课的最大值（当然i是必须要选的）

 

结果发现转移为：

 

F[i][j] = max{ sigma( F[i.son[n]][kn] } + v[i]

 

sigma( kn ) = m-1

 

灾难，如果你看不懂我的不标准的符号语言，就是需要找一个序列 k1,k2,k3..kn （i节点有n个孩子），要满足

 

F[i.son[1]][k1] + F[i.son[2]][k2] ... + F[i.son[n]][kn] 最大，且k1+k2...+kn = m-1

 

这样就是我用背包来解，效率也太慢了。

 

所以我想难道广为流传的转成二叉树的做法难道有什么精妙之处？看了网上的题解，发现原来是状态表示的问题。

 

同样，我把原来的状态该为: F[i][j]表示以i为根的树及他右边的兄弟（树），选j门课的最大值。

 

则转移为：

 

F[i][j] = max{ F[i.brother][j]  ,  F[i.son][k] + F[i.brother][j-k-1] + v[i] }

( 0<=k<j

 

再添加一个节点，把所有树的最上边的根作为他的孩子，这样森林就变成了一棵树。

 

只是在处理这个无意义的节点的时候需要注意，不是需要这个节点选择了其孩子节点才能选择的，且该节点根本不能选修。

 

所以在这个节点是  转移因为: max{ F[i.son][k] + F[i.brother][j-k] }

 

#include <iostream> using namespace std; const int _DEF_NON = -1; int _gN,_gM; int _gSon[301],_gBrother[301],_gValue[301]; //0 int _gFront[301]; int _gDp[301][301]; void _fInit() { cin >> _gN >> _gM; for( int i = 0;i <= _gN;++i ) { for( int j = 0;j <= _gM;++j ) _gDp[i][j] = _DEF_NON; } _gValue[0] = 0; _gSon[0] = _DEF_NON; _gBrother[0] = _DEF_NON; int tin; for( int i = 1;i <= _gN;++i ) { cin >> tin >> _gValue[i]; _gFront[i] = tin; _gSon[i] = _DEF_NON; _gBrother[i] = _DEF_NON; _gDp[i][0] = 0; } } void _fBuildTree( int n ) { for( int i = 1;i <= _gN;++i ) { if( _gFront[i] == n ) { if( _gSon[n] == _DEF_NON ) _gSon[n] = i; else { int f = _gSon[n],a = _gSon[n]; while( a != _DEF_NON ) { f = a; a = _gBrother[a]; } _gBrother[f] = i; } _fBuildTree(i); } } } int _f( int n,int m ) { if( _gDp[n][m] != _DEF_NON ) return _gDp[n][m]; int max; if( _gSon[n] == _DEF_NON ) { max = _gValue[n]; if( _gBrother[n] != _DEF_NON ) { if( _f( _gBrother[n],m ) > max ) max = _f( _gBrother[n],m ); if( _f( _gBrother[n],m-1 ) + _gValue[n] > max ) max = _f( _gBrother[n],m-1 ) + _gValue[n]; } _gDp[n][m] = max; return _gDp[n][m]; } if( _gBrother[n] == _DEF_NON ) { _gDp[n][m] = _f( _gSon[n],m-1 ) + _gValue[n]; if( n == 0 ) _gDp[n][m] = _f( _gSon[n],m ); return _gDp[n][m]; } max = _f( _gBrother[n],m ); int ta,tb; for( int k = 0;k < m;++k ) { ta = _f( _gSon[n],k ); tb = _f( _gBrother[n],m-k-1 ); if( ta + tb + _gValue[n] > max ) max = ta + tb + _gValue[n]; } _gDp[n][m] = max; return _gDp[n][m]; } int main() { _fInit(); _fBuildTree( 0 ); cout << _f( 0,_gM ) << endl; return 0; } 

 

 

 

 

2.题目描述：

 

 

通向自由的钥匙(key.pas/c/cpp)

通向自由的钥匙被放n个房间里，这n个房间由n-1条走廊连接。但是每个房间里都有特别的保护魔法，在它的作用下，我无法通过这个房间，也无法取得其中的钥匙。虽然我可以通过消耗能量来破坏房间里的魔法，但是我的能量是有限的。那么，如果我最先站在1号房间（1号房间的保护魔法依然是有效的，也就是，如果不耗费能量，我无法通过1号房间，也无法取得房间中的钥匙），如果我拥有的能量为P，我最多能取得多少钥匙？

输入数据

第一行包含两个非负整数，第一个为N，第二个为P。

接下来n行，按1~n的顺序描述了每个房间。第i+1行包含两个非负整数cost和keys，分别为第i件房取消魔法需要耗费的能量和房间内钥匙的数量。

接下来n-1行，每行两个非负整数x,y，表示x号房间和y号是连通的。

输出数据

一行一个整数，表示取得钥匙的最大值。

样例

输入:key.in

5 5

1 2

1 1

1 1

2 3

3 4

1 2

1 3

2 4

2 5

输出: key.out

7

数据范围

对于20%的测试数据，有n<=20

对于30%的测试数据，有n<=30

对于所有测试数据，有p,n<=100, cost <= Maxint, keys<= Maxint

 

 

这题的算法和选课是一样的，cost和key  和选课的用法本质是相同的。这题我写的是转为二叉树的解。发现用二叉树解其实也蛮方便的。

 

#include <iostream> #include <fstream> using namespace std; const int _D_SIZE = 150; const int _D_NON = -1; int _gleft[_D_SIZE],_gright[_D_SIZE],_gdp[_D_SIZE][_D_SIZE],_gn,_gp; int _gcost[_D_SIZE],_gv[_D_SIZE],_gta[_D_SIZE],_gtb[_D_SIZE],_gdone[_D_SIZE]; int _fmax( int a,int b ) { return a > b ? a : b; } void _finit() { ifstream fin("key.in"); fin >> _gn >> _gp; for( int i = 1;i <= _gn;++i ) fin >> _gcost[i] >> _gv[i]; for( int i = 1;i < _gn;++i ) fin >> _gta[i] >> _gtb[i]; fin.close(); for( int i = 1;i <= _gn;++i ) { _gleft[i] = _gright[i] = _D_NON,_gdone[i] = false; for( int j = 0;j <= _gp;++j ) _gdp[i][j] = _D_NON; } } void _finsert( int f,int s ) //二叉树 { int ls = _gleft[f]; if( ls == _D_NON ) { _gleft[f] = s; return ; } while( _gright[ls] != _D_NON ) ls = _gright[ls]; _gright[ls] = s; } void _fbuildTree( int n ) //以n为根建树 { _gdone[n] = true; for( int i = 1;i < _gn;++i ) { if( _gta[i] == n && _gdone[ _gtb[i] ] == false ) { _finsert( n,_gtb[i] ); _fbuildTree( _gtb[i] ); } if( _gtb[i] == n && _gdone[ _gta[i] ] == false ) { _finsert( n,_gta[i] ); _fbuildTree( _gta[i] ); } } } int _fwork( int n,int p ) { if( _gdp[n][p] != _D_NON ) return _gdp[n][p]; if( _gleft[n] == _D_NON ) { _gdp[n][p] = p >= _gcost[n] ? _gv[n] : 0; if( _gright[n] == _D_NON ) return _gdp[n][p]; if( p >= _gcost[n] ) _gdp[n][p] = _fmax( _gv[n] + _fwork( _gright[n],p-_gcost[n] ),_fwork( _gright[n],p ) ); else _gdp[n][p] = _fwork( _gright[n],p ); return _gdp[n][p]; } if( _gright[n] == _D_NON ) { _gdp[n][p] = 0; if( p < _gcost[n] ) return _gdp[n][p]; _gdp[n][p] = _gv[n] + _fwork( _gleft[n],p-_gcost[n] ); return _gdp[n][p]; } _gdp[n][p] = _fwork( _gright[n],p ); if( p < _gcost[n] ) return _gdp[n][p]; int max = 0,end = p - _gcost[n]; for( int i = 0;i <= end;++i ) max = _fmax( max,_fwork( _gleft[n],i ) + _fwork( _gright[n],end - i ) + _gv[n] ); _gdp[n][p] = _fmax( max,_gdp[n][p] ); return _gdp[n][p]; } int main() { _finit(); _fbuildTree( 1 ); ofstream fout("key.out"); fout << _fwork( 1,_gp ) << endl; fout.close(); return 0; }