HDU 2146 (Hash)

本来是用字典树的 用了很多种优化竟然都超时 那就只好用hash了 对所有的串进行重构 化为64位整型 然后使用位运算枚举所有K长串

 

然后用hash存储 使用线性扫描法  还可以优化

 

代码如下：

 

 

 

#include <iostream>
using namespace std;

typedef struct  
{
    unsigned __int64 key;
    long num;
}Info;

Info hash[68000];
char key[80];

__int64 prime;
long lmax=0;
inline void Dohash(unsigned __int64 key)
{
    long pos=key%prime;

    if (hash[pos].num==0)
    {
        hash[pos].num=1;
        hash[pos].key=key;
        if (hash[pos].num>lmax)
        {
            lmax=hash[pos].num;
        }
        return;
    }

    if (hash[pos].key==key)
    {
        ++hash[pos].num;
        if (hash[pos].num>lmax)
        {
            lmax=hash[pos].num;
        }
        return;
    }

    long i,j;
    long l;
    for (i=1;;++i)
    {
        for (j=0;j<2;++j)
        {
            if (!(j&1))
            {
                l=(pos+i)%prime;
                if (hash[l].num==0)
                {
                    hash[l].num=1;
                    hash[l].key=key;
                    if (hash[pos].num>lmax)
                    {
                        lmax=hash[pos].num;
                    }
                    return;
                }
                if (hash[l].key==key)
                {
                    ++hash[l].num;
                    if (hash[pos].num>lmax)
                    {
                        lmax=hash[pos].num;
                    }
                    return;
                }
            }
            else
            {
                l=(pos+prime-i)%prime;
                if (hash[l].num==0)
                {
                    hash[l].num=1;
                    hash[l].key=key;
                    if (hash[pos].num>lmax)
                    {
                        lmax=hash[pos].num;
                    }
                    return;
                }
                if (hash[l].key==key)
                {
                    ++hash[l].num;
                    if (hash[pos].num>lmax)
                    {
                        lmax=hash[pos].num;
                    }
                    return;
                }
            }
        }
    }
}


int main()
{    
    long N,L,K;
    prime=(1<<16)+1;
    while (scanf("%ld %ld %ld",&N,&L,&K)!=EOF)
    {
        lmax=0;
        memset(hash,0,sizeof(hash));
        unsigned __int64 mask=0;
    
        long i;
        long j;

        for (i=0;i<K;++i)
        {
            mask=(mask<<1)+1;
        }


        for (i=0;i<N;++i)
        {
            scanf("%s",key);
            unsigned __int64 sum=0;
            
            for (j=0;key[j]!='\0';++j)
            {
                sum=(sum<<1)+(key[j]-'0');
            }

            long len=L;
            while (len-K>=0)
            {
                unsigned __int64 t=(sum&mask);
                sum=sum>>1;
                Dohash(t);
                --len;
            }
        }
        printf("%ld\n",lmax);
    }
    return 0;
}