hdu 4351 Digital root

我花了两天才把标程完全理解了T T（看题解实在太云里雾里了！！！）可能是我没理解好题意。

看完代码之后我才发现位运算实在太强大……强大到让人难以理解，有木有！

两case之间有一空行！最后的case不给空行！结果两个PE……

还有一种离线的办法。有空打下贴上。-2012.8.11

由于教主贴上这题，于是重温了一下……

楼下的代码已经忘得7788 ， 基本上算是自己打了一遍，也算把这道看标程理解的题目真正自己做了一次。

题解：区间更新 + 位处理

分别有两个难点：

一：节点信息

每个节点有三个信息

1.左端开始连续能产生的root

2.右端开始连续能产生的root

3.区间内能产生的root

4.整个区间产生的root

二：root的合并

预处理一个数组add[i][j] 表示 i 包含的数字根 与 j 包含的数字根  放到一起能产生的新的数字根的集合（ps：i、j 均可为多个root集合，因为是用位表示的。 ps2：新的集合不包含原有数字根，即不包含i , j)

为了弄出add这个数组，又预处理一个pass[i][j]数组= =！ 表示 i 这个root 和  j 这个集合放一起产生的新的 root 集合。

本次题解详情见第二个代码

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
const int maxx = 100010;
struct po
{
    int state,L,R,root;
    int l,r;
} point[maxx<<2];//root为该节点L~R的数字根, L表示的是从区间的左端点开始，当逐个增加元素时产生的新的root的集合,R同理,state表示L~R所有存在的数字根
int add[1<<10|1][1<<10|1];
int crazy[1<<10|1][1<<10|1];
int val[maxx];

inline int change(int x)
{
    if(x%9==0)
    {
        if(x==0)
            return 0;
        else
            return 9;
    }
    else
        return x%9;
}

void ini()//这个初始化非常V5，我看了两天就搁在这两数组上面了……
{
    for(int i=1;i<=1024;i++)
    {
        for(int j=0;j<=9;j++)
        {
            add[i][j] = 0;
            for(int k=0;k<=9;k++)
            {
                if(i & (1<<k))//如果 i 包含了 k 这一个 root
                    add[i][j] |= 1<<change(k+j);//则赋予add[i][j]这个数组 k 和 j 产生的新的 root
            }//具体需要结合上面L的解释 以加以理解add[][]这个数组的意义
        }
    }
    for(int i=1;i<=1024;i++)
    {
        for(int j=i;j<=1024;j++)
        {
            crazy[i][j] = crazy[j][i] = 0;
            for(int k=0;k<=9;k++)
            {
                if(j & (1<<k))
                    crazy[i][j] |= add[i][k];//i为被合并的左儿子的R，j为被合并的右儿子的L，crazy[i][j]表示两个区间合并在一起的时候产生的所有新的数字根
            }
            crazy[j][i] = crazy[i][j];
        }
    }
}


void update(po& p1, po p2, po p3)
{
    p1.L = p2.L | add[p3.L][p2.root];
    p1.R = p3.R | add[p2.R][p3.root];
    p1.root = change(p2.root + p3.root);
    p1.state = p2.state|p3.state|crazy[p2.R][p3.L];
}

void build(int left, int right,int dex)
{
    point[dex].l = left;
    point[dex].r = right;
    if(point[dex].l == point[dex].r)
    {
        point[dex].root = change(val[left]);
        point[dex].L = point[dex].R = point[dex].state= 1<<point[dex].root;
        return ;
    }
    int mid = (point[dex].l + point[dex].r)>>1;
    build(left,mid,dex<<1);
    build(mid+1,right,dex<<1|1);
    update(point[dex],point[dex<<1],point[dex<<1|1]);
}

po query(int left, int right, int dex)
{
    if(point[dex].l == left && point[dex].r == right)
        return point[dex];
    int mid = (point[dex].l + point[dex].r)/2;
    if(right<=mid)
        return query(left,right,dex<<1);
    else if(left>=mid+1)
        return query(left,right,dex<<1|1);
    else//由于被询问的l r在不连续的区间里面，所以要考虑合并产生新的元素！
    {
        po ll = query(left,mid,dex<<1);
        po rr = query(mid+1,right,dex<<1|1);
        po tem;
        update(tem,ll,rr);
        return tem;
    }
}

int main()
{
//    freopen("1002.txt","r",stdin);
    ini();
    int t;
    scanf("%d",&t);
    for(int cases=1; cases<=t; cases++)
    {
        if(cases!=1)
            printf("\n");
        memset(point,0,sizeof(point));
        printf("Case #%d:\n",cases);
        int n;
        scanf("%d",&n);
        for(int i=1; i<=n; i++)
            scanf("%d",&val[i]);
        build(1,n,1);
        int q;
        scanf("%d",&q);
        while(q--)
        {
            int l,r;
            scanf("%d%d",&l,&r);
            int state = query(l,r,1).state;
            int tem = 0;
            for(int i=9; i>=0 && tem<5; i--)
            {
                if(tem==0 && state & (1<<i))
                {
                    printf("%d",i);
                    tem++;
                }
                else if(tem!=0 && state & (1<<i))
                {
                    printf(" %d",i);
                    tem++;
                }
                else
                    continue;
            }
            if(tem!=5)
                for(int i=tem; i<5; i++)
                {
                    if(i==0)
                        printf("-1");
                    else
                        printf(" -1");
                }
            printf("\n");
        }
    }
    return 0;
}

———————————————————————————————分割线———————————————————————————————————————

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define lson l , mid , dex<<1
#define rson mid + 1 , r , dex<<1|1
#define havemid int mid = (l + r) >> 1

using namespace std;
const int Max = 100100;
int add[1025][1025];
int pass[10][1025];

struct se
{
    int root_l , root_r , root_a , root , dex;
    se(int a = 0 , int b = 0 , int c = 0 , int d = 0 , int e = 0):root_l(a) , root_r(b) , root_a(c) , root(d) , dex(e) {}
    bool check()
    {
        if(!root_l && !root_r && !root_a && !root)
            return true;
        else
            return false;
    }
} seg[Max<<2];

void out_root(int x)
{
    for(int i = 0 ; i <= 9 ; i++)
        if(x & (1 << i))
            printf("%d " , i);
}

int Find_root(int x)
{
    int tem = 0;
    while(x)
    {
        tem += x%10;
        x /= 10;
    }
    if(tem < 10)
        return tem;
    else
        Find_root(tem);
}
inline int handle(int add , int root)
{
    int tem = 0;
    for(int i = 9 ; i >= 0 ; i--)
    {
        if(root & (1<<i))
            tem |= (1 << Find_root(i + add));
    }
    return tem;
}
inline int handle2(int one , int second)
{
    int tem = 0;
    for(int i = 9 ; i >= 0 ; i--)
        if(one & (1 << i))
            tem |= pass[i][second];
    return tem;
}
void init()
{
    memset(pass , 0 , sizeof(pass));
    for(int i = 0 ; i <= 9 ; i ++)//pay attention! "i" is the root number  "j" is the value of the root number in binary system
        for(int j = 1 ; j <= 1024 ; j ++)
            pass[i][j] = handle(i , j);

    for(int i = 0 ; i <= 1024 ; i++)
        for(int j = i ; j <= 1024 ; j++)
            add[i][j] = add[j][i] = handle2(i , j);

}


se Push_up(se lsn , se rsn)
{
    se father;
    if(lsn.check() && !rsn.check()) return father = rsn;
    else if(!lsn.check() && rsn.check()) return father = lsn;
    else if(lsn.check() && rsn.check())   return father;
    father.root_a = add[lsn.root_a][rsn.root_a];
    father.root_l = lsn.root_l | add[lsn.root_a][rsn.root_l];
    father.root_r = rsn.root_r | add[rsn.root_a][lsn.root_r];
    father.root   = father.root_l | father.root_r | add[lsn.root_r][rsn.root_l] | lsn.root | rsn.root;
    return father;
}

void build(int l , int r , int dex)
{
    if(l == r)
    {
        int tem;
        scanf("%d" , &tem);
        seg[dex].root_a = seg[dex].root_l = seg[dex].root_r = seg[dex].root |= (1 << Find_root(tem));
//        root_a[dex] = root_l[dex] = root_r[dex] = root[dex] |= (1 << Find_root(tem));
        return;
    }
    havemid;
    build(lson);
    build(rson);
    seg[dex] = Push_up(seg[dex<<1] , seg[dex<<1|1]);
}

inline void m_out(int x)
{
    int counter = 0;
    int ans[5];
    for(int i = 9 ; i >= 0 ; i--)
    {
        if(counter == 5)    break;
        if(x & (1<<i))
            ans[counter++] = i;
    }
    if(!counter)
        printf("-1 -1 -1 -1 -1");
    else
    {
        printf("%d" , ans[0]);
        for(int i = 1 ; i < counter ; i++)
            printf(" %d" , ans[i]);
        for(int i = counter ; i < 5 ; i++)
            printf(" -1");
    }
    printf("\n");
}

se query(int L , int R , int l , int r , int dex)
{
    if(L <= l && R >= r)
        return seg[dex];
    havemid;
    se tem_L , tem_R , tem_ans;
    if(L <= mid)    tem_L = query(L , R , lson);
    if(R >  mid)    tem_R = query(L , R , rson);
    tem_ans = Push_up(tem_L , tem_R);
    return tem_ans;
}

int main()
{
//    freopen("DG.txt","r",stdin);
    int t , cases = 1;
    scanf("%d" , &t);
    init();
    while(t--)
    {
        printf("Case #%d:\n" , cases++);
        memset(seg , 0 , sizeof(seg));
        int n;
        scanf("%d" , &n);
        build(1 , n , 1);

        int m;
        scanf("%d" , &m);
        for(int i = 1 ; i <= m ; i++)
        {
            int a , b;
            scanf("%d %d" , &a , &b);
            se ans = query(a , b , 1 , n , 1);
            m_out(ans.root);
        }
        if(t != 0)
            printf("\n");
    }
}