题目题意异常恶心,难以理解……

　　呵呵…..不过题意是 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代码:

View Code

#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..虽然不好,总也是自己想了好久的……

View Code

#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;
}