poj 2414 Phylogenetic Trees Inherited 完全二叉树 状态压缩位运算模拟集合操作 动态规划
题目题意异常恶心,难以理解......
呵呵.....不过题意是 Lyush大神 花费一小时看明白后透露给笔者的, 到现在依然YM此大婶当中......
先说说题目大意:
一颗完全二叉树,有 N ( n <= 1024,且必定为2的整数幂,意味着是一颗完全二叉树 ) 个叶子节点,
每一个节点都含有一个长度为 L L ( L <= 1000 ) 的串 ( 串仅由大写字母构成), 现仅仅知道N个叶子节点串的组成.
其他节点串不知道.
但我们知道,直接父节点相同的两个子节点,其对应位置不同则花费为1. 整棵树花费最小.
让你求,整棵树的最小花费, 以及根节点的可能串元素组成.若有多种情况则随意输出一种即可. ( Special Judge )
解题思路:
第一点我们知道每一个串中不同位置间无约束条件. 所以我们可以分别处理.
定义函数
T( rt ) 表示以 rt 为根节点的二叉树最小花费值
A( rt ) 表示以 rt 为根节点的二叉树最小花费值时, 可选取的字符的集合
那么,若对于 有相同直接父节点 rt 的节点 lch, rch 已得出 T( lch ), A( lch ) 与 T( rch ), A( rch)
那么对于 其父节点 rt 来看, 若 T( rt ) 要取得最优解, 则
or
//这里的并与交,指代集合的操作
对于这个结论,我们可以通过归纳法证明:
有三种情况:
一, 当 , 则 lch,rch位置字符与rt仅有一个不同 花费 cost = 1
二, 当 , 则 lch,rch位置字符与rt都相同 花费 cost = 0
三, 当, 则lch,rch位置字符与rt两两间都不同,花费 cost = 2
所以我们可以得出结论.
当且仅当, , 此时其父节点rt,
, 并且此时花费 cost = 0
否则, 此时 , 其父节点rt,
, 并且此时 子节点 lch, rch 中必有一个与根节点不同,所以花费cost = 1
换句话说,我们每次合并集合,则花费cost必定+1
关于编码技巧问题, 这里我们除了将不同位置分开处理之外, 还可以观察到, 串元素仅有大写字母A-Z组成,共26个.属于int范围内.
因为可选项最多26个,若我们用数组来模拟集合,则势必多一层26的循环,时间复杂度增大不少, 我们可以使用 位运算,状态压缩到一个 int 值当中,
这样集合的 交与并 操作则可以使用 位运算的 &与| 来替代.
AC代码:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#include<stdio.h> #include<string.h> #include<stdlib.h> char seq[1024][1024]; int T[2048], n, m; int main() { while( scanf("%d%d", &n,&m) , n+m ) { for(int i = 0; i < n; i++) scanf("%s", seq[i]); int cost = 0; for(int p = 0; p < m; p++) { for(int x = 0; x < n; x++) T[x+n] = 1<<(seq[x][p]-'A'); for(int rt = n-1; rt >= 1; rt-- ) { int lch = rt<<1, rch = rt<<1|1; T[rt] = T[lch]&T[rch]; if( T[rt] == 0 ) { T[rt] = T[lch] | T[rch]; cost++; } } char ch = 'A'; while( (T[1]&1) == 0 ) { ch++; T[1] >>= 1; } printf("%c", ch ); } printf(" %d\n", cost ); } return 0; }
再贴个搓代码, 前面直接模拟的写法,外加数组模拟集合操作,时间+空间一起T..虽然不好,总也是自己想了好久的......
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#include<stdio.h> #include<string.h> #include<stdlib.h> #include<math.h> const int inf = 0x3fffffff; typedef long long LL; #define MIN(a,b) (a)<(b)?(a):(b) struct Node { bool num[1001][27]; // 27001 Byte char s[1001]; // 1001 Byte }node[1100<<1]; // 2200 5*10^7 B int n, m, mf; LL ans; void print_n( int rt ) { printf("rt = %d\n", rt ); for(int p = 0; p < m; p++) { printf("p=%d : ", p); for(int op = 0; op < 26; op++) { printf("%d ", node[rt].num[p][op] ); } printf("\n\n"); } } void print_s( int rt ) { printf("rt = %d: ",rt); for(int p = 0; p < m; p++) printf("%d ", node[rt].s[p] ); puts(""); } void init() { //初始化最后一层可选项 for(int i = n; i < n+n; i++ ) { memset( node[i].num, 0, sizeof( node[i].num ) ); for(int p = 0; p < m; p++) node[i].num[p][ node[i].s[p]-'A' ] = true; } // 从下层 log2(n)+1 往上更新固定值,或单一固定值 // 对于无法确定的则保存下当前可选择项 // 预处理最后一层与上一层的关系 for(int f = mf; f > 1; f-- ) { //第f层有 (2^(f-1)) 个节点, 且从 (2^(f-1))开始 int x = 1<<(f-1); for(int lch = x; lch < x+x; lch += 2 ) { int rch = lch+1, fa = lch/2; //printf("fa = %d, lch = %d, rch = %d\n", fa, lch, rch ); //初始化父节点fa,可选项 memset( node[fa].num, 0, sizeof(node[fa].num) ); node[fa].s[m] = '\0'; //对每个构造串手动添加字符串结尾标志 // 处理每个位置p, 位置总长m for(int p = 0; p < m; p++) { //printf("l.s=%d,r.s=%d\n",node[lch].s[p],node[rch].s[p] ); if( (node[lch].s[p] == 0) || (node[rch].s[p] == 0) ) { node[fa].s[p] = 0; } else{ //左右子节点 串p 位置都为固定值 if( node[lch].s[p] != node[rch].s[p] ) node[fa].s[p] = 0; else node[fa].s[p] = node[lch].s[p]; } for(int ch = 0; ch < 26; ch++ ) node[fa].num[p][ch] = (node[lch].num[p][ch] || node[rch].num[p][ch]); } // print_s(fa); } } } // 以rt为根节点的树, 其父节点选择fa_op的最小花费 int dfs( int p, int rt, int fa_op ) { int floor = (int)(log2(1.*rt))+1; //目前层数 int fa = rt/2; bool flag = false; // 标记值,判定节点rt是否需要选择,默认为不需要 // 若节点rt, p位置字符固定,则该节点下面的子树该位置都相同,无需继续选择 // 因为mf层,都没确定值,则当递归到mf层时,必定开始回溯. if( node[rt].s[p] != 0 ) { if( node[rt].s[p]-'A' == fa_op ) return 0; else return 1; } else { //若不确定,则分为两种情形: // 一,当节点rt,包含其父节点fa_op选项时选择,rt同时选择该选项 // 二,当节点rt,不包含其父节点fa_op选项时,rt开始枚举选择最优选项 .并且此时导致 花费+1 LL c = 0; if( node[rt].num[p][ fa_op ] == true ) { c += dfs( p, rt<<1, fa_op ); c += dfs( p, rt<<1|1, fa_op); return c; } else { // 此时应在所有可选项中取一个最小值 c = inf; for(int op = 0; op < 26; op++) { LL tmp = 0; if( node[rt].num[p][op] == true ) { //若当前op可选 tmp += dfs( p, rt<<1, op ); tmp += dfs( p, rt<<1|1, op ); c = MIN( c, tmp ); } } return c+1; //因为此位置与父节点不想符合,造成花费额外+1 } } } void solve(){ ans = 0; // 总花费 // 确定位置P 最小花费cost,以及最佳选项 for(int p = 0; p < m; p++) { // 若p位置字符不确定,则进行搜索 // printf("node[1].s[%d] = %d\n",p, node[1].s[p] ); // printf("%d ", node[1].s[p] ); if( node[1].s[p] == 0 ) { LL cost = inf; int ch = -1; for(int op = 0; op < 26; op++) { //printf(" node[%d].num[%d][%d] = %d\n", 1, p, op, node[1].num[p][op] ); if( node[1].num[p][op] ) //当前字符可选 { LL c = 0; // 初始化 当选择OP选项时,最小花费 //假定 父串p位置取op选项,然后递归处理下一层 c += dfs( p, 2, op ); //位置p, 子树根2, 父节点选项op c += dfs( p, 3, op ); // printf("c = %lld\n", c ); if( cost > c ) //取最小花费c,所在选项op { cost = c; ch = op; } } } //确定p位置字符为 ch, 最小花费为 cost; ans += cost; node[1].s[p] = ch+'A'; // printf("ch = %d, cost = %lld\n", ch, cost ); } } //输出 printf("%s %lld\n", node[1].s, ans ); } int main() { freopen("8.in","r", stdin); freopen("8.out","w",stdout); while( scanf("%d%d", &n,&m) , n+m ) { mf = (int)(log2(1.*n))+1; //printf("mf = %d\n", mf ); for(int i = n; i < n+n; i++) scanf("%s", node[i].s ); // 由下而上更新 可确定项,以及生成可选项 init(); // 由上而下搜索位置p 可选项取最小值 solve(); } return 0; }