POJ 1200 Crazy Search

最新推荐文章于 2019-10-30 17:24:56 发布
最新推荐文章于 2019-10-30 17:24:56 发布
阅读量483 收藏
点赞数
分类专栏： Hash 字符串
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/speedcell4/article/details/12851741
版权

试验一发Bllizard的字符串哈希函数……

/*
 Author : Speedcell
 Update : 2013-10-08
Version : soppYcell 2.3
*/

#include <algorithm>
#include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>

#include <map>
#include <set>
#include <list>
#include <stack>
#include <queue>
#include <deque>
#include <vector>
#include <string>
#include <bitset>
#include <memory>
#include <complex>
#include <numeric>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include <ctype.h>
#include <locale.h>

using namespace std;

#pragma pack(4)

#ifndef __CONSTANT__
#define __CONSTANT__

typedef long long LONG;

const double pi = acos(-1.0);
const int   inf = 0x7f7f7f7f;
const LONG  INF = 0x7f7f7f7f7f7f7f7fll;

const int go[8][2] = {{0,1},{0,-1},{1,0},{-1,0},{1,1},{1,-1},{-1,1},{-1,-1}};

#endif // __CONSTANT__

#ifndef __IO__
#define __IO__

inline bool RD(int    & a) {return scanf("%d",&a)!=EOF;}
inline bool RD(char   & a) {return scanf("%c",&a)!=EOF;}
inline bool RD(char   * a) {return scanf("%s", a)!=EOF;}
inline bool RD(double & a) {return scanf("%lf",&a)!=EOF;}
inline bool RD(LONG   & a) {return scanf("%I64d",&a)!=EOF;}

template<class T1> inline bool
    IN(T1 & a) {return RD(a);}
template<class T1,class T2> inline bool
    IN(T1 & a,T2 & b) {return RD(a)&&RD(b);}
template<class T1,class T2,class T3> inline bool
    IN(T1 & a,T2 & b,T3 & c) {return RD(a)&&RD(b)&&RD(c);}
template<class T1,class T2,class T3,class T4> inline bool
    IN(T1 & a,T2 & b,T3 & c,T4 & d) {return RD(a)&&RD(b)&&RD(c)&&RD(d);}
template<class T1,class T2,class T3,class T4,class T5> inline bool
    IN(T1 & a,T2 & b,T3 & c,T4 & d,T5 & e) {return RD(a)&&RD(b)&&RD(c)&&RD(d)&&RD(e);}
template<class T1,class T2,class T3,class T4,class T5,class T6> inline bool
    IN(T1 & a,T2 & b,T3 & c,T4 & d,T5 & e,T6 & f) {return RD(a)&&RD(b)&&RD(c)&&RD(d)&&RD(e)&&RD(f);}
template<class T1,class T2,class T3,class T4,class T5,class T6,class T7> inline bool
    IN(T1 & a,T2 & b,T3 & c,T4 & d,T5 & e,T6 & f,T7 & g) {return RD(a)&&RD(b)&&RD(c)&&RD(d)&&RD(e)&&RD(f)&&RD(g);}

inline void PT(int    a) {printf("%d",a);}
inline void PT(char   a) {printf("%c",a);}
inline void PT(char * a) {printf("%s",a);}
inline void PT(double a) {printf("%f",a);}
inline void PT(LONG   a) {printf("%I64d",a);}
inline void PT(const char a[]) {printf("%s",a);}

template<class T1> inline void
    OT(T1 a) {PT(a);}
template<class T1,class T2> inline void
    OT(T1 a,T2 b) {PT(a),PT(' '),PT(b);}
template<class T1,class T2,class T3> inline void
    OT(T1 a,T2 b,T3 c) {PT(a),PT(' '),PT(b),PT(' '),PT(c);}
template<class T1,class T2,class T3,class T4> inline void
    OT(T1 a,T2 b,T3 c,T4 d) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d);}
template<class T1,class T2,class T3,class T4,class T5> inline void
    OT(T1 a,T2 b,T3 c,T4 d,T5 e) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT(' '),PT(e);}
template<class T1,class T2,class T3,class T4,class T5,class T6> inline void
    OT(T1 a,T2 b,T3 c,T4 d,T5 e,T6 f) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT(' '),PT(e),PT(' '),PT(f);}
template<class T1,class T2,class T3,class T4,class T5,class T6,class T7> inline void
    OT(T1 a,T2 b,T3 c,T4 d,T5 e,T6 f,T7 g) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT(' '),PT(e),PT(' '),PT(f),PT(' '),PT(g);}

template<class T1> inline void
    OL(T1 a) {PT(a),PT('\n');}
template<class T1,class T2> inline void
    OL(T1 a,T2 b) {PT(a),PT(' '),PT(b),PT('\n');}
template<class T1,class T2,class T3> inline void
    OL(T1 a,T2 b,T3 c) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT('\n');}
template<class T1,class T2,class T3,class T4> inline void
    OL(T1 a,T2 b,T3 c,T4 d) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT('\n');}
template<class T1,class T2,class T3,class T4,class T5> inline void
    OL(T1 a,T2 b,T3 c,T4 d,T5 e) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT(' '),PT(e),PT('\n');}
template<class T1,class T2,class T3,class T4,class T5,class T6> inline void
    OL(T1 a,T2 b,T3 c,T4 d,T5 e,T6 f) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT(' '),PT(e),PT(' '),PT(f),PT('\n');}
template<class T1,class T2,class T3,class T4,class T5,class T6,class T7> inline void
    OL(T1 a,T2 b,T3 c,T4 d,T5 e,T6 f,T7 g) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT(' '),PT(e),PT(' '),PT(f),PT(' '),PT(g),PT('\n');}

#endif // __IO__

#ifndef __MACRO__
#define __MACRO__

#define ML(times) int tcase; IN(tcase); FOR(times,1,tcase)

#define FOR(i,a,b) for(int i=int(a),_##i=int(b);i<=_##i;i++)
#define DWN(i,b,a) for(int i=int(b),_##i=int(a);_##i<=i;i--)
#define ECH(i,u,pre,next) for(int i=int(pre[u]);i!=-1;i=int(next[i]))

#define MEM(a,v) memset(a,v,sizeof(a))
#define CLR(a,v) FOR(_i##a,0,sizeof(a)/sizeof(a[0])-1) a[_i##a]=v

#define LOOP(a,n)                                               \
    FOR(_i##a,0,(n)-1)                                          \
        OT(a[_i##a]),OT(_i##a!=__i##a?' ':'\n')
#define LOOP2(a,n,m)                                            \
    FOR(_i##a,0,(n)-1) FOR(_j##a,0,(m)-1)                       \
        OT(a[_i##a][_j##a]),OT(_j##a!=__j##a?' ':'\n')
#define LOOPG(G,n,pre,next)                                     \
    FOR(_i##a,0,(n)-1) ECH(_j##a,_i##a,pre,next)                \
        OL(_i##a,G[_j##a].v,G[_j##a].w)

#endif // __MACRO__

#ifndef __BIT__
#define __BIT__

template<class T> inline T lb(T i) {return i&-i;}
template<class T> inline T lc(T i) {return i<<1;}
template<class T> inline T rc(T i) {return i<<1|1;}
template<class T> inline T at(T a,int i) {return a& (T(1)<<i);}
template<class T> inline T nt(T a,int i) {return a^ (T(1)<<i);}
template<class T> inline T s1(T a,int i) {return a| (T(1)<<i);}
template<class T> inline T s0(T a,int i) {return a&~(T(1)<<i);}

#endif // __BIT__

#ifndef __COMPARER__
#define __COMPARER__

const double eps = 1e-8;

inline int cmp(double a,double b=0) {return fabs(b-a)<eps?0:((b-a)<eps?+1:-1);}
template<typename type> inline int cmp(type a,type b=0) {return a==b?0:(b<a?+1:-1);}

template<typename type> inline bool gt(type a,type b) {return cmp(a,b)> 0;}
template<typename type> inline bool ge(type a,type b) {return cmp(a,b)>=0;}
template<typename type> inline bool eq(type a,type b) {return cmp(a,b)==0;}
template<typename type> inline bool ne(type a,type b) {return cmp(a,b)!=0;}
template<typename type> inline bool le(type a,type b) {return cmp(a,b)<=0;}
template<typename type> inline bool ls(type a,type b) {return cmp(a,b)< 0;}

template<typename type> inline type smax(type a,type b) {return gt(a,b)?a:b;}
template<typename type> inline type smin(type a,type b) {return ls(a,b)?a:b;}

#endif // __COMPARER__

const int MAXV = 1600002;

class Bllizard
{
private:
	unsigned crypt[1300];

	struct node
	{
		bool exit;
		unsigned hashA;
		unsigned hashB;
		unsigned hashC;
	}table[MAXV];
public:
    Bllizard(void)
    {
        unsigned seed=0x00100001;
        for(unsigned index1=0;index1<0x100;index1++)
        {
            for(unsigned index2=index1,i=0;i<5;i++,index2+=0x100)
            {
                seed=(seed*125+3)%0x2aaaab;
                unsigned temp1=(seed&0xffff)<<0x10;
                seed=(seed*125+3)%0x2aaaab;
                unsigned temp2=(seed&0xffff);
                crypt[index2]=(temp1|temp2);
            }
        }
    }
    void clear(void)
    {
    	MEM(table,0);
    }
    unsigned hashString(char a[],unsigned type,int L,int R)
    {
        unsigned seed1=0x7fed7fed;
        unsigned seed2=0xeeeeeeee;
        FOR(i,L,R)
        {
            unsigned ch=toupper(a[i]);
            seed1=crypt[(type<<8)+ch]^(seed1+seed2);
            seed2=ch+seed1+seed2+(seed2<<5)+3;
        }
        return seed1;
    }
    int insert(char a[],int L,int R)
    {
    	unsigned hashA=hashString(a,0,L,R);
        unsigned hashB=hashString(a,1,L,R);
        unsigned hashC=hashString(a,2,L,R);
        for(int i=hashA%MAXV;;i=(i+1)%MAXV)
        {
        	if(!table[i].exit)
			{
				table[i].exit=true;
				table[i].hashA=hashA;
				table[i].hashB=hashB;
				table[i].hashC=hashC;
				return i;
			}
        }
        return -1;
    }
    int search(char a[],int L,int R)
    {
        unsigned hashA=hashString(a,0,L,R);
        unsigned hashB=hashString(a,1,L,R);
        unsigned hashC=hashString(a,2,L,R);
        for(int i=hashA%MAXV;;i=(i+1)%MAXV)
        {
        	if(!table[i].exit) break;
        	else
			{
        		if(table[i].hashA!=hashA) continue;
				if(table[i].hashB!=hashB) continue;
				if(table[i].hashC!=hashC) continue;
				return i;
			}
        }
        return -1;
    }
}bllizard;

int n,m;
char a[MAXV];

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("Crazy Search.txt","r",stdin);
    #else
    #endif

    while(IN(n,m,a))
	{
		int ans=0;
		bllizard.clear();
		FOR(i,0,strlen(a)-n)
		{
			if(bllizard.search(a,i,i+n-1)==-1)
			{
				ans++;
				bllizard.insert(a,i,i+n-1);
			}
		}
		OL(ans);
	}

    return 0;
}

Speedcell
关注
专栏目录
POJ 1200 Crazy Search（哈希算法）【模板】
风的记忆
08-17 1093
Many people like to solve hard puzzles some of which may lead them to madness. One such puzzle could be finding a hidden prime number in a given text. Such number could be the number of different substrings of a given size that exist in the text. As you so
Crazy Search （哈希算法）
厄尔尼诺的博客
08-17 1116
Crazy Search 给定一个字符串，其中含有不同的字母数量为m，现在求这个字符串中有多少个长度为n且长的互不相同的字符子串 举个例子, n=3, m=4 ，字符串 “daababac”. 长度为3的不同的子串分别是: “daa”; “aab”; “aba”; “bab”; “bac”. 因此, 答案是5. Input 第一行是两个整数n,m,，一个空格隔开。 接下来一行是...
POJ - 1200 A - crazy search
Rainbow__sea的博客
10-26 355
A - Crazy Search Many people like to solve hard puzzles some of which may lead them to madness. One such puzzle could be finding a hidden prime number in a given text. Such number could be the number
POJ1200 A - Crazy Search（哈希）
weixin_30819085的博客
09-23 205
A - Crazy Search Many people like to solve hard puzzles some of which may lead them to madness. One such puzzle could be finding a hidden prime number in a given text. Such number could be the n...
Crazy Search POJ - 1200 （简单哈希）
lwgkzl的博客
08-08 380
Crazy Search Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 29481   Accepted: 8191 Description Many people like to solve hard puzzles some of which may le
POJ1200 Crazy Search
AlexTYJ的博客
05-07 155
POJ1200 Crazy Search 本题题目没给数据范围！！！但是它给了输出结果不大于1.6* 107 所以本题就可以用字符串hash，只需要mod1.6*107就可以了 由于最多只有nc种字符，我们直接用nc进制字符串hash就行了 对于字符串hash，我们从直观上讲是每次都要hash=hash+pow(x,p)的 但是在实现的过程中我们可以hash=hash*p+x； 这样少掉一个pow...
poj 1200 Crazy Search
young TO challenge！
05-15 720
题目：     链接：点击打开链接 题意：     输入n和nc，以及字符串s，输出长度为n的不同字串的个数。 算法：      思路：     用hash判重（hash值。。。。。。），看了大牛的代码，对hash还是不甚理解。。。。 代码：#include #include #include #include using namespace std; #define MAXN 1
poj1200 Crazy Search
JIBANCANYANG
10-11 475
@(K ACMer)题意:给你一个字符串,其中由nc个不同的字符组成.问你它的长度为n的不同的子序列有多少个?分析: 咋一看最直接的想法就是每一个子串都加入set中,然后最后看set中有多少个字符串就可以了.复杂度是O(n∗strlen∗logn)O(n*strlen*log^n)显然超时. 那么有什么优化呢? 我们可以看出每次往set中添一个字符串,这个字符串会和已经有的字符串比较是否相等,比较的
poj 1200 Crazy Search HASH 哈希表
kongming_acm的专栏
03-04 657
Crazy SearchTime Limit: 1000MS Memory Limit: 65536KTotal Submissions: 13667 Accepted: 3753<br />DescriptionMany people like to solve hard puzzles some of which may lead them to madness. One such puzzle could be finding a hidden prime number in a given text
POJ_1200 Crazy Search ( Hash映射 )
♡ 脚下的每一步都叫远方 ♡
09-12 188
题目连接 题意 给一个含有nc个不同字母的字符串，然后求其中有多少个长度为n的不同子串. 题解 因为题目中给出了nc，即字母种类的个数。所以可以把每一个出现的字母对应为1到nc。然后把长度为n的字符串映射成为一个整数。即把这个字符串看成一个nc进制的数。 代码 #include<cstdio> #include<cstring> using namespace std; #...
POJ 1200-Crazy Search【滚动哈希】
独钓门前月
10-30 371
描述 许多人喜欢解决难题，其中一些难题可能会使他们疯狂。一个这样的难题可能是在给定的文本中找到隐藏的素数。该数字可以是文本中存在的给定大小的不同子字符串的数量。您很快就会发现，您确实需要计算机的帮助和良好的算法来解决这一难题。 您的任务是编写一个程序，该程序给定子字符串的大小N，文本NC中可能出现的不同字符的数目以及文本本身，确定出现在字符串中的大小为N的不同子字符串的数目。文本。 例如，考虑N...
POJ题目解题报告大全(Java)[1]
我是传奇
11-12 998
POJ 1001 Exponentiation [解题报告] JavaPOJ 1002 487-3279 [解题报告] JavaPOJ 1003 Hangover [解题报告] JavaPOJ 1004 Financial Management [解题报告] JavaPOJ 1005 I Think I Need a Houseboat [解题报告] JavaPOJ 1006 Biorhythms...
HOJ 12717 Cookie Selection
10-10 632
我可以说这题我是SBT写的么…… /* Author : Speedcell Update : 2013-10-08 Version : soppYcell 2.3 */ #include #include #include #include #include #include #include #include #include #include #includ
基于java学生宿舍管理系统设计与实现.docx
09-19
基于java学生宿舍管理系统设计与实现.docx
2023-04-06-项目笔记 - 第二百六十一阶段 - 4.4.2.259全局变量的作用域-259 -2025.09.19
最新发布
09-19
2023-04-06-项目笔记-第二百六十一阶段-课前小分享_小分享1.坚持提交gitee 小分享2.作业中提交代码 小分享3.写代码注意代码风格 4.3.1变量的使用 4.4变量的作用域与生命周期 4.4.1局部变量的作用域 4.4.2全局变量的作用域 4.4.2.1全局变量的作用域_1 4.4.2.259局变量的作用域_259- 2024-09-19
小程序-轻客洗衣.zip
09-19
小程序-轻客洗衣.zip
基于java的海鲜自助餐厅系统设计与实现.docx
09-19
基于java的海鲜自助餐厅系统设计与实现.docx
POJ编程题解资源集合
"这些题目是来自POJ (Programming Online Judge) 的一系列算法练习题，涵盖了基础到中等难度的编程问题。题目涉及了各种算法和数据结构，包括但不限于数学计算、字符串处理、逻辑推理、递归、动态规划、位运算等。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值