ural1486_二维hash匹配

最新推荐文章于 2017-08-28 10:44:01 发布
最新推荐文章于 2017-08-28 10:44:01 发布
阅读量531 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/t163ang/article/details/12280889
版权 
#include<iostream>
#include<map>
#include<string>
#include<algorithm>
#include<bitset>
#include<cassert>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<queue>
#include<stack>
#include<vector>
#include<ctime>
#include<set> 
#include<cctype>
#include<cstdlib>
using namespace std;
const double eps=1e-7;
const int K=1024;
const int maxn= 502;
const int maxh=maxn*maxn;
const int INF = (1<<30);
typedef unsigned long long ULL;
//#define debug
const int P=975637;
const int Q=773331;
const int P2=977717;
const int Q2=773371;
int n,m,tot,ans_L;
char G[maxn][maxn];
int R,R2,p1[maxn],p2[maxn],p3[maxn],p4[maxn],hs_r[maxn][maxn],hs2_r[maxn][maxn],hs_t[maxn][maxn],hs2_t[maxn][maxn],hs_f[maxh];
pair<int,int> ans[2],vec[maxh][2];
void init(){
	p1[1]=p2[1]=1;
	p3[1]=p4[1]=1;
	for(int i = 2; i <= m; ++i) {
		p1[i]=((ULL)p1[i-1]*26)%Q;
		p3[i]=((ULL)p3[i-1]*26)%Q2;
	}
	R=((ULL)p1[m]*26)%Q;
	R2=((ULL)p3[m]*26)%Q2;
	for(int i = 2; i <= n; ++i) {
		p2[i]=((ULL)p2[i-1]*R)%P; 
		p4[i]=((ULL)p4[i-1]*R2)%P2;
	}
}
bool ts(int len){
	for(int i = 1;i <= n; ++i){
		hs_r[i][1]=0;
		hs2_r[i][1]=0;
		for(int j = 1;j <= len; ++j){
			hs_r[i][1]=((ULL)hs_r[i][1]*26+G[i][j])%Q;
			hs2_r[i][1]=((ULL)hs2_r[i][1]*26+G[i][j])%Q2;
		}
		for(int j = 2;j <= m-len+1; ++j){
			hs_r[i][j]=((26*(Q+hs_r[i][j-1]-((ULL)p1[len]*G[i][j-1])%Q)%Q)%Q+G[i][j+len-1])%Q; 
			hs2_r[i][j]=((26*(Q2+hs2_r[i][j-1]-((ULL)p3[len]*G[i][j-1])%Q2)%Q2)%Q2+G[i][j+len-1])%Q2; 
		}
	}
	for(int j = 1; j <=m-len+1; ++j){
		hs_t[1][j]=0;
		hs2_t[1][j]=0;
		for(int i = 1; i <= len; ++i){
			hs_t[1][j]=((ULL)hs_t[1][j]*R + hs_r[i][j])%P;
			hs2_t[1][j]=((ULL)hs2_t[1][j]*R2 + hs2_r[i][j])%P2;
		}
		for(int i = 2; i <= n-len+1;++i){
			hs_t[i][j]=((R*(P+hs_t[i-1][j]-((ULL)hs_r[i-1][j]*p2[len])%P)%P)%P+hs_r[i+len-1][j])%P;
			hs2_t[i][j]=((R2*(P2+hs2_t[i-1][j]-((ULL)hs2_r[i-1][j]*p4[len])%P2)%P2)%P2+hs2_r[i+len-1][j])%P2;
		}
	}
	memset(hs_f,0,sizeof(hs_f));
	tot=0;
	for(int i = 1;i <= n-len+1; ++i){
		for(int j = 1; j <= m-len+1; ++j){
			int u=hs_t[i][j],v=hs2_t[i][j];
			int h=((ULL)u*v) % maxh;
			if(u>v) swap(u,v);
			while(hs_f[h]){
				if(vec[hs_f[h]][0].first==u&&vec[hs_f[h]][0].second==v){
					bool flag=true;
					int ii=vec[hs_f[h]][1].first,jj=vec[hs_f[h]][1].second;
					for(int x = 0; flag&&x < len; ++x){
						for(int y = 0; y < len; ++y){
							if(G[x+i][y+j]!=G[x+ii][y+jj]){flag=false;break;}
						}
					}
					if(flag){
						if(ans_L < len){
							ans_L=len;
							ans[0].first=ii;
							ans[0].second=jj;
							ans[1].first=i;
							ans[1].second=j;
						}
						return true;
					}
				}
				++h;
				if(h==maxh) h=0;
			}
			hs_f[h]=++tot;
			vec[tot][0].first=u;
			vec[tot][0].second=v;
			vec[tot][1].first=i;
			vec[tot][1].second=j;
		}
	}
	return false;
}
int main(){
	//freopen("in.txt","r",stdin);
	scanf("%d%d",&n,&m);
	for(int i = 1; i <= n; ++i){
		scanf("%s",&G[i][1]);
		for(int j = 1; j <= m; ++j) G[i][j]-='a';
	}
	init();
	int left=1,right=min(n,m);
	while(left<=right){
		int mid=(left+right)>>1;
		if(ts(mid)) left=mid+1;
		else right=mid-1;
	}
	if(ans_L>0){
		printf("%d\n",ans_L);
		printf("%d %d\n",ans[0].first,ans[0].second);
		printf("%d %d\n",ans[1].first,ans[1].second);
	}else puts("0");
	return 0;
}


//#include<iostream>
//#include<map>
//#include<string>
//#include<algorithm>
//#include<bitset>
//#include<cassert>
//#include<cstring>
//#include<cmath>
//#include<cstdio>
//#include<queue>
//#include<stack>
//#include<vector>
//#include<ctime>
//#include<set> 
//#include<cctype>
//#include<cstdlib>
//using namespace std;
//const double eps=1e-7;
//const int K=1024;
//const int maxn= 510;
//const int INF = (1<<30);
//typedef unsigned long long ULL;
//#define debug
//const int P=95565617;
//const int Q=3333371;
//const int P2=75565617;
//const int Q2=3133371;
//int n,m,pn,ans_L;
//char G[maxn][maxn];
//int R,p1[maxn],p2[maxn],hs_r[maxn][maxn],hs_t[maxn][maxn];
//multimap<int,pair<int,int> > cf;
//typedef multimap<int,pair<int,int> >::iterator cfit;
//pair<int,int> ans[2],ans2;
//bool cmp(int h,int w,int len){
//	 cfit itlow=cf.lower_bound(hs_t[h][w]);
//	 cfit itup =cf.upper_bound(hs_t[h][w]);
//	 for(cfit it=itlow; it != itup; ++it){
// 		ans2=it->second;
//		bool flag=true;
//		for(int i = 0; flag&&i < len; ++i){
//			for(int j = 0; j < len; ++j){
//				if(G[i+h][j+w]!=G[i+ans2.first][j+ans2.second]){
//					flag=false;
//					break;
//				}
//			}
//		}
//		if(flag){
//			if(ans_L < len){
//				ans_L=len;
//				ans[0]=ans2;
//				ans[1].first=h;
//				ans[1].second=w;
//				if(ans[0]>ans[1]) swap(ans[0],ans[1]);
//			}
//			return true;
//		}
//	 }
//	 return false;
//}
//bool ts(int len){
//	for(int i = 1;i <= n; ++i){
//		hs_r[i][1]=0;
//		//hs2_r[i][1]=0;
//		for(int j = 1;j <= len; ++j){
//			hs_r[i][1]=((ULL)hs_r[i][1]*26+G[i][j])%Q;
//			//hs2_r[i][1]=(hs2_r[i][1]*26+G[i][j])%Q2;
//		}
//		for(int j = 2;j <= m-len+1; ++j){
//			hs_r[i][j]=(
//				(26*(Q+hs_r[i][j-1]-((ULL)p1[len]*G[i][j-1])%Q)%Q)%Q
//				+G[i][j+len-1]
//			)%Q; 
//			/*hs2_r[i][j]=(
//				(26*(Q2+hs2_r[i][j-1]-(p3[len]*G[i][j-1])%Q2)%Q2)%Q2
//				+G[i][j+len-1]
//			)%Q2;*/
//		}
//	}
//	for(int j = 1; j <=m-len+1; ++j){
//		hs_t[1][j]=0;
//		//hs2_t[1][j]=0;
//		for(int i = 1; i <= len; ++i){
//			hs_t[1][j]=((ULL)hs_t[1][j]*R + hs_r[i][j])%P;
//			//hs2_t[1][j]=(hs2_t[1][j]*R2 + hs2_r[i][j])%P2;
//		}
//		for(int i = 2; i <= n-len+1;++i){
//			hs_t[i][j]=(
//				((ULL)R*((ULL)P+hs_t[i-1][j]-((ULL)hs_r[i-1][j]*p2[len])%P)%P)%P
//				+hs_r[i+len-1][j]
//			)%P;
//		/*	hs2_t[i][j]=(
//				(R2*(P2+hs2_t[i-1][j]-(hs2_r[i-1][j]*p4[len])%P2)%P2)%P2
//				+hs2_r[i+len-1][j]
//			)%P2;*/
//		}
//	}
//#ifdef debug
//	printf("len:%d\n",len);
//	printf("%d %d\n",hs_r[1][1],hs_r[3][3]);
//	printf("%d %d\n",hs_t[1][1],hs_t[3][3]);
//#endif
//	cf.clear();
//	for(int i = 1;i <= n-len+1; ++i){
//		for(int j = 1; j <= m-len+1; ++j){
//			pair<int,int> t(i,j);
//			if(cmp(i,j,len)){
//				return true;
//			}
//			cf.insert(make_pair(hs_t[i][j],t));
//		}
//	}
//	return false;
//}
//int main(){
//	freopen("in.txt","r",stdin);
//	scanf("%d%d",&n,&m);
//	for(int i = 1; i <= n; ++i){
//		scanf("%s",&G[i][1]);
//		for(int j = 1; j <= m; ++j) G[i][j]-='a';
//	}
//	//no.1 hash
//	p1[1]=p2[1]=(ULL)1;
//	for(int i = 2; i <= m; ++i) p1[i]=(p1[i-1]*26)%Q;
//	R=(p1[m]*26)%Q;
//	for(int i = 2; i <= n; ++i) p2[i]=(p2[i-1]*R)%P;
//	//no.2 hash
//	/*p3[1]=p4[1]=(ULL)1;
//	for(int i = 2; i <= m; ++i) p3[i]=(p3[i-1]*26)%Q2;
//	R2=(p3[m]*26)%Q2;
//	for(int i = 2; i <= n; ++i) p4[i]=(p4[i-1]*R2)%P2;*/
//
//    int left=1,right=min(n,m);
//	while(left<=right){
//		int mid=(left+right)>>1;
//		if(ts(mid)) left=mid+1;
//		else right=mid-1;
//	}
//	if(ans_L>0){
//		printf("%d\n",ans_L);
//		printf("%d %d\n",ans[0].first,ans[0].second);
//		printf("%d %d\n",ans[1].first,ans[1].second);
//	}else puts("0");
//	return 0;
//}

编码请看：http://www.maidoupig.cn

t163ang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
acm_ural_1148
11-05
Pascal acm_timus_ural_1148.pas
ural1486 二分+二维哈希
litble的成(tui)长(fei)史
08-14 595
题目大意给你一个矩阵，在里面找两个最大的相同的子正方形矩阵（可重叠，输出正方形边长和两个正方形的左上角坐标）题目分析首先二分正方形矩阵的边长，然后哈希每一个这样的正方形矩阵即可。 哈希的方法如下（x是矩阵中的元素） 然后容斥解决每一个子矩阵。（具体看代码，但是…看的时候请冷静点，因为很长） ⎡⎣⎢x1∗p2∗q3x5∗p∗q2x9∗q3x2∗p2∗q2x6∗p∗q2x10∗q2x3∗p2∗qx
URAL - 1486 Equal Squares 哈希、二维hash、二分、卡大素数
ProLights的博客
03-12 1229
题意：给出n个长度为m的字符串(n,m <= 500)，然后问选取一个最大的正方形，使得有2个正方形区域的字符串是相同的，求出这个最大正方形的边长即两次出现位置的正方形左上角坐标。 哈希、二维hash、二分、卡大素数 题目直接就暗示着用哈希来做 ^_^， 然后可以把每个字符串分别用同一个大素数hash掉， 然后二分边长， check的时候，检查每个长度为mid的正方形是否再次出现， 检查的时候再去另一个大素数pt，把横向的第一次哈希得到的一段字符串的哈希值作为一个元素，把这些元素再次进行哈希， 然后在纵向的
URAL 1486 Equal Squares
Occult
02-19 485
During a discussion of problems at the Petrozavodsk Training Camp, Vova and Sasha argued about who of them could in 300 minutes find a pair of equal squares of the maximal size in a matrix of size N ×
URAL 1486（二维字符串hash）
xiefubao的专栏
11-17 1690
题意：一个最大500*500的字符矩阵，求最大的两个相同的字符正方形。正方形可以有重叠部分但不能重合。 解法：首先是二分正方形的长度，然后判断某个长度存在时候计算字符矩阵的二维hash值，二维hash的方法是： 这样子拓展的hash算法可以O(1) 获取任意一个子矩阵的hash值。 代码：/*********************************
牛客网 二维哈希（哈希的正确姿势）
MR CODER
08-28 2124
时间限制：1秒 空间限制：131072K 题目描述 给出一个n * m的矩阵。让你从中发现一个最大的正方形。使得这样子的正方形在矩阵中出现了至少两次。输出最大正方形的边长。 输入描述: 第一行两个整数n, m代表矩阵的长和宽； 接下来n行，每行m个字符（小写字母），表示矩阵； 输出描述: 输出一个整数表示满足条件的最大正方形的边长。 示例1 输入 5
Ural 1486. Equal Squares 字符串hash
停不下的脚步
08-14 1601
1486. Equal Squares Time limit: 2.0 second Memory limit: 16 MB During a discussion of problems at the Petrozavodsk Training Camp, Vova and Sasha argued about who of them could in 300 minute
acm_ural_1099
11-05
Pascal acm_timus_ural_1099.pas
Philip_Dural_UX-UI_Designer:UXUI设计器配置文件
03-30
Philip_Dural_UX-UI_Designer:UXUI设计器配置文件
Ural
10-25
Ural
ural
03-17
乌拉尔
前18大旋转修整器企业占据全球87%的市场份额.docx
05-06
前18大旋转修整器企业占据全球87%的市场份额
Planet-SkySat-Imagery-Product-Specification-Jan2020.pdf
05-06
SKYSAT IMAGERY PRODUCT SPECIFICATION PLANET.COM VIDEO Full motion videos are collected between 30 and 120 seconds by a single camera from any of the active SkySats. Videos are collected using only the Panchromatic half of the camera, hence all videos are PAN only. Videos are packaged and delivered with a video mpeg-4 file, plus all image frames with accompanying video metadata and a frame index file (reference Product Types below)
Screenshot_20240506_133458_com.netease.yhtj.vivo.jpg
05-06
Screenshot_20240506_133458_com.netease.yhtj.vivo.jpg
2019年A~F题特等奖论文合集.pdf
05-06
大学生，数学建模，美国大学生数学建模竞赛，MCM/ICM，历年美赛特等奖O奖论文
雷达物位变送器安装和操作手册
05-06
雷达物位变送器安装和操作手册
node-v11.6.0-linux-armv7l.tar.xz
最新发布
05-06
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
Python3实现快速排序（源代码）
05-06
快速排序是一种基于分治策略的排序算法，通过选择一个基准元素，将待排序的数组划分为两个子数组，一个包含所有小于基准的元素，另一个包含所有大于基准的元素，然后递归地对这两个子数组进行快速排序。快速排序在平均情况下具有O(n log n)的时间复杂度，是一种非常高效的排序算法。然而，在最坏情况下，当输入数据已经有序或接近有序时，快速排序的性能会退化为O(n^2)。此外，快速排序是不稳定的排序算法，即相等的元素可能在排序过程中改变相对位置。尽管如此，快速排序仍然因其高效的平均性能而在实际应用中广泛使用。在Python3中，可以通过递归或迭代的方式实现快速排序算法，但为了避免额外的空间开销，通常会采用原地排序的方式来实现。
Ural 1029 Ministry 题解
05-31
Ural 1029 Ministry 是一道比较简单的贪心题目，以下是一种可行的思路： 首先，我们可以考虑对所有的数字进行排序，然后从小到大依次遍历这些数字。对于每一个数字，我们需要判断它是否可以被当前的部门所处理。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值