BZOJ 3899 仙人掌树的同构 仙人掌同构+KMP算法

原创 2015年07月10日 14:01:14

题目大意:给定一棵仙人掌,求有多少自同构

仙人掌同构问题= =
曾经出过一个判断两个仙人掌是否同构的题,感觉和这个题很类似

首先假设这是一棵树,考虑怎么做

我们首先找到树的重心(如果有两个就在中间加一个点变成一个)
然后把树Hash
对于一棵树 如果某一哈希值的子树有k个 就把答案乘上一个k!

现在变成了仙人掌,那么我把每个环变成一个红点连向环上的所有点,然后把原先环上的边拆除,可以得到一棵树,按树同构做就行了

为了区分红点和普通点的区别,需要为红点设置不同的哈希参数

但是这样有一个BUG,就是原先环上的点是有顺序的,而变成树之后也需要有序

因此对于一个红点,如果它不是树的根节点,计算贡献的时候判断将环翻转是否与原来相同即可
Hash的时候正反Hash两遍,取最小值

如果它是树的根节点,问题就变为了给定一个环判断有多少自同构,只需要正反跑两遍KMP即可

注意大小为2的环不存在翻转同构问题(即不需要考虑翻转,不过这题没有大小为2的环= =)

最后把所有贡献乘在一起就是答案

(我怎么跑得这么快啊这么快

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define M 1010
#define MOD 1000000003
#define ORI1 2333
#define ORI2 23333
#define BASE1 999911657
#define BASE2 999911659
#define END1 18357
#define END2 81643
using namespace std;
int n,m;
long long ans=1;
long long fac[M];
unsigned long long A[M],B[M<<1];int len;
int next[M];
void Pretreatment()
{
    int i;
    for(fac[0]=1,i=1;i<=1000;i++)
        fac[i]=fac[i-1]*i%MOD;
}
int KMP()
{
    int i,fix=0,re=0;
    for(i=2;i<=len;i++)
    {
        while( fix && A[fix+1]!=A[i] )
            fix=next[fix];
        if( A[fix+1]==A[i] )
            ++fix;
        next[i]=fix;
    }
    for(i=1;i<=len;i++)
        B[i]=B[i+len]=A[i];
    fix=0;
    for(i=1;i<len<<1;i++)
    {
        while( fix && A[fix+1]!=B[i] )
            fix=next[fix];
        if( A[fix+1]==B[i] )
            ++fix;
        if(fix==len)
            ++re,fix=next[fix];
    }
    if(len>2)
    {
        for(i=1;i<len;i++)
            swap(B[i],B[len+len-i]);
        fix=0;
        for(i=1;i<len<<1;i++)
        {
            while( fix && A[fix+1]!=B[i] )
                fix=next[fix];
            if( A[fix+1]==B[i] )
                ++fix;
            if(fix==len)
                ++re,fix=next[fix];
        }
    }
    return re;
}
namespace Tree{
    int n,root;
    struct abcd{
        int to,next;
    }table[M<<2];
    int head[M<<1],tot;
    int cg[2];
    unsigned long long hash[M];
    void Add(int x,int y)
    {
        table[++tot].to=y;
        table[tot].next=head[x];
        head[x]=tot;
    }
    int Get_Centre_Of_Gravity(int x,int from)
    {
        int i,re=1,flag=true;
        for(i=head[x];i;i=table[i].next)
            if(table[i].to!=from)
            {
                int temp=Get_Centre_Of_Gravity(table[i].to,x);
                if(temp<<1>n) flag=false;re+=temp;
            }
        if(n-re<<1>n) flag=false;
        if(flag) (cg[0]?cg[1]:cg[0])=x;
        return re;
    }
    void Tree_DP(int x,int from)
    {
        int i,top=0;
        for(i=head[x];i;i=table[i].next)
            if(table[i].to!=from)
                Tree_DP(table[i].to,x);
        static unsigned long long stack[M];
        if(x<=::n)
        {
            for(i=head[x];i;i=table[i].next)
                if(table[i].to!=from)
                    stack[++top]=hash[table[i].to];
            sort(stack+1,stack+top+1);
            int temp=0;
            for(i=1;i<=top;i++)
            {
                ++temp;
                if(i==top||stack[i]!=stack[i+1])
                {
                    (ans*=fac[temp])%=MOD;
                    temp=0;
                }
            }
            hash[x]=ORI1;
            for(i=1;i<=top;i++)
                (((hash[x]*=BASE1)+=stack[i])^=stack[i])+=stack[i];
            ((hash[x]+=END1)*=END1)^=END1;
        }
        else if(x!=root)
        {
            for(i=head[x];i;i=table[i].next)
                if(table[i].to==from)
                    break;
            for(i=table[i].next;i;i=table[i].next)
                stack[++top]=hash[table[i].to];
            for(i=head[x];table[i].to!=from;i=table[i].next)
                stack[++top]=hash[table[i].to];
            for(i=1;i<=top;i++)
                if(stack[i]!=stack[top+1-i])
                    break;
            if(top>=2&&i==top+1)
                (ans<<=1)%=MOD;
            unsigned long long hash1,hash2;
            hash1=ORI2;
            for(i=1;i<=top;i++)
                (((hash1*=BASE2)+=stack[i])^=stack[i])+=stack[i];
            ((hash1+=END2)*=END2)^=END2;
            hash2=ORI2;
            for(i=top;i;i--)
                (((hash2*=BASE2)+=stack[i])^=stack[i])+=stack[i];
            ((hash2+=END2)*=END2)^=END2;
            hash[x]=min(hash1,hash2);
        }
        else
        {
            for(i=head[x];i;i=table[i].next)
                A[++len]=hash[table[i].to];
            (ans*=KMP())%=MOD;
        }
    }
    void Calculate()
    {
        int i;
        Get_Centre_Of_Gravity(1,0);
        if(!cg[1])
            root=cg[0];
        else
        {
            root=++n;
            for(i=head[cg[0]];i;i=table[i].next)
                if(table[i].to==cg[1])
                {
                    table[i].to=root;
                    break;
                }
            for(i=head[cg[1]];i;i=table[i].next)
                if(table[i].to==cg[0])
                {
                    table[i].to=root;
                    break;
                }
            Add(root,cg[0]);
            Add(root,cg[1]);
        }
        Tree_DP(root,0);
    }
}
namespace Cactus{
    struct abcd{
        int to,next;
    }table[M<<2];
    int head[M],tot=1;
    bool v[M],over[M],on_ring[M];
    int from[M];
    void Add(int x,int y)
    {
        table[++tot].to=y;
        table[tot].next=head[x];
        head[x]=tot;
    }
    void DFS(int x,int from)
    {
        int i,j;
        v[x]=true;
        for(i=head[x];i;i=table[i].next)
            if(i^from^1)
            {
                if(!v[table[i].to])
                {
                    Cactus::from[table[i].to]=x;
                    on_ring[x]=false;
                    DFS(table[i].to,i);
                    if(!on_ring[x])
                    {
                        Tree::Add(x,table[i].to);
                        Tree::Add(table[i].to,x);
                    }
                }
                else
                {
                    if(over[table[i].to])
                        continue;
                    ++Tree::n;
                    for(j=x;;j=Cactus::from[j])
                    {
                        Tree::Add(Tree::n,j);
                        Tree::Add(j,Tree::n);
                        on_ring[j]=true;
                        if(j==table[i].to)
                            break;
                    }

                }
            }
        over[x]=true;
    }
}
int main()
{
    int i,x,y;
    cin>>n>>m;
    Tree::n=n;
    Pretreatment();
    for(i=1;i<=m;i++)
    {
        scanf("%d%d",&x,&y);
        Cactus::Add(x,y);
        Cactus::Add(y,x);
    }
    Cactus::DFS(1,0);
    Tree::Calculate();
    cout<<ans<<endl;
    return 0;
}

相关文章推荐

hdu4807(最小费用最大流)

题意:给定n点m边有向图,每条边同时可以承载若干人同时经过,每个人的速度均为单位时间通过一条边。K个人从0点开始走向n-1点,问最后一个人走到n-1点的最早时间...

【HEOI2013】bzoj3168 钙铁锌硒维生素

矩阵求逆+二分图匹配
  • sdfzyhx
  • sdfzyhx
  • 2017年03月13日 11:11
  • 228

【BJOI2015】【BZOJ4337】树的同构

Description树是一种很常见的数据结构。 我们把N个点,N-1条边的连通无向图称为树。 若将某个点作为根,从根开始遍历,则其它的点都有一个前驱,这个树就成为有根树。 对于两个树T1和T2...

BZOJ 3197 Sdoi2013 assassin 动态规划+树同构+费用流

题目大意:给定一棵树和两组权值,求第一组权值最少改变多少个之后这棵树经过重标号之后与第二组权值相同 这个题做法很神- - 首先和3162一样的处理方式 我们先找到这棵树的重心作为根 如果重心有两个就新...
  • PoPoQQQ
  • PoPoQQQ
  • 2015年01月27日 23:35
  • 1794

bzoj 4337: BJOI2015 树的同构 (树hash)

题目描述传送门题目大意:对于两个树T1和T2,如果能够把树T1的所有点重新标号,使得树T1和树T2完全相 同,那么这两个树是同构的。给你M个有根树,请你把它们按同构关系分成若干个等价类。题解感觉树h...

[树的同构][二分][可并堆维护哈希] LOJ#6066 || BZOJ4928 && 2017 山东一轮集训 Day3. 第二题

这题一看就可以二分 那么解决这题的关键就变成了怎么对树进行哈希,以及怎么快速维护哈希值 想了一个下午想了一个比较靠谱的哈希方法。 用一个p进制数(p>n且为质数)来表示每一个节点,这个数有dep...
  • Coldef
  • Coldef
  • 2017年07月11日 18:07
  • 219

BZOJ 4337: BJOI2015 树的同构|Hash

此题三战三卒……!! 一卒:没有考虑连边的顺序。 二卒:用排序解决了连边的顺序,然后用重心似乎搞不了…… 三卒:考虑到rp问题,换了换hash的数..三卒! 扔了重心终于A掉了 可以用括...
  • ws_yzy
  • ws_yzy
  • 2016年02月13日 17:21
  • 608

BZOJ 4337 BJOI2015 树的同构 Hash

题目给定mm棵无根树,求每棵树与其同构的树的最小编号。 1≤N,M≤501\leq N,M\leq 50分析考虑hashhash,要求不涉及编号对答案的影响,且为了确保正确用2个Hash。 我使用...

【Hash】bzoj4337 BJOI2015树的同构

树的哈希
  • Flanoc
  • Flanoc
  • 2017年07月09日 13:15
  • 126

古代算法同构C实现

  • 2013年04月14日 14:06
  • 399B
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:BZOJ 3899 仙人掌树的同构 仙人掌同构+KMP算法
举报原因:
原因补充:

(最多只允许输入30个字)