POJ 3690 找星座（2D匹配）（未解答）

最新推荐文章于 2020-06-13 21:29:35 发布
最新推荐文章于 2020-06-13 21:29:35 发布
阅读量702 收藏
点赞数 1
分类专栏： POJ 文章标签： poj 字符串匹配
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21201267/article/details/93662491
版权

文章目录

1. 题目信息

1.1 题目链接

http://poj.org/problem?id=3690

1.2 题目大意

给定大的矩阵（天空的样子），然后给定若干小矩阵（可能的天空的一角）
求有多少个小矩阵是从大矩阵里抠出来的（2D匹配）

1.3 解题思路

采用RK算法，求矩阵的哈希值，看哈希值是否一样，若一样，再比较一下看是否真的一样（防止哈希冲突）

2. 代码

2.1 Time Limit Exceeded 代码

在这里插入图片描述
计算的是整体矩阵的哈希值

/**
 * @description: poj3690 2维矩阵匹配
 * @author: michael ming
 * @date: 2019/6/25 19:47
 * @modified by: 
 */
#include <iostream>
#include <math.h>
using namespace std;
int a[1001][1001];
int b[51][51];
typedef unsigned long long ull;
ull cal_hash_b(int r, int c, int b[][51])
{
    int i, j, k;
    ull value = 0;
    for (i = 0; i < r; ++i) //计算2d模式串的hash值value
    {
        for(j = 0, k = 1; j < c; ++j,++k)
            value += b[i][j]*pow(2.0,k);
    }
    return value;
}
ull cal_hash_a_child(int i0, int j0, int r, int c, int a[][1001])
{
    int i, j, k;
    ull hash_value = 0;
    for (i = i0; i < r; ++i) //计算2d子串的hash值value
    {
        for(j = j0, k = 1; j < c; ++j,++k)
            hash_value += a[i][j]*pow(2.0,k);
    }
    return hash_value;
}
bool same(int a[][1001], int b[][51], int i0, int j0, int mr, int mc)
{
    int x = i0, y = j0, i, j;
    for(i = 0; i < mr; ++i,++x)
    {
        for(j = 0, y = j0; j < mc; ++j,++y)//记得写y=j0,换行后y复位
        {
            if(a[x][y] != b[i][j])
                return false;
        }
    }
    return true;
}
int str_RK_2d(int a[][1001], int nr, int nc, int b[][51], int mr, int mc)//s是主串，t是模式串
{
    int i, j;
    ull hash_val, value;
    value = cal_hash_b(mr,mc,b);//计算2d模式串哈希值
    for(i = 0; i < nr-mr+1; ++i)//行最多nr-mr+1次比较
    {
        for(j = 0; j < nc-mc+1; ++j)//列最多nc-mc+1次比较
        {
            hash_val = cal_hash_a_child(i,j,mr+i,mc+j,a);//计算2d子串哈希值
            if(hash_val == value && same(a,b,i,j,mr,mc))
            {//如果2d子串哈希值等于模式串的，且"真的"字符串匹配（避免冲突带来的假匹配）
                return 1;
            }
        }
    }
    return 0;
}
void creatMatrix_a(int a[][1001], int r, int c)
{
    int i, j;
    char ch;
    for(i = 0; i < r; ++i)
        for(j = 0; j < c; ++j)
        {
            cin >> ch;
            if(ch == '*')
                a[i][j] = 1;
            else
                a[i][j] = 0;
        }
}
void creatMatrix_b(int b[][51], int r, int c)
{
    int i, j;
    char ch;
    for(i = 0; i < r; ++i)
        for(j = 0; j < c; ++j)
        {
            cin >> ch;
            if(ch == '*')
                b[i][j] = 1;
            else
                b[i][j] = 0;
        }
}
int main()
{
    int N, M, T, P, Q, count, ID = 1;
    while(cin >> N >> M >> T >> P >> Q && N)
    {
        count = 0;
        creatMatrix_a(a,N,M);
        while(T--)
        {
            creatMatrix_b(b,P,Q);
            count += str_RK_2d(a,N,M,b,P,Q);
        }
        cout << "Case " << ID++ << ": " << count << endl;
    }
    return 0;
}

2.2 Time Limit Exceeded 代码

优化了哈希值的计算方式，采用错位乘以2的方式，2的k次幂提前算好(还试了改成位运算)，都是超时

/**
 * @description: poj3690 2维矩阵匹配
 * @author: michael ming
 * @date: 2019/6/25 19:47
 * @modified by:
 */
#include <iostream>
using namespace std;
typedef unsigned long long ull;
int a[1001][1001];
int b[51][51];
ull cal_hash_b(int r, int c, int b[][51])
{
    int i, j, k;
    ull value = 0;
    for (i = 0; i < r; ++i) //计算2d模式串的hash值value
    {
        for(j = 0, k = c-1; j < c; ++j,--k)
        {
            value += b[i][j]<<k;
        }
    }
    return value;
}
ull cal_hash_a_child(int i0, int j0, int r, int c, int a[][1001])
{
    int i, j, k;
    ull hash_value = 0;
    for (i = i0; i < r; ++i) //计算2d子串的hash值value
    {
        for(j = j0, k = c-1; j < c; ++j,--k)
            hash_value += a[i][j]<<k;
    }
    return hash_value;
}
bool same(int a[][1001], int b[][51], int i0, int j0, int mr, int mc)
{
    int x = i0, y = j0, i, j;
    for(i = 0; i < mr; ++i,++x)
    {
        for(j = 0, y = j0; j < mc; ++j,++y)//记得写y=j0,换行后y复位
        {
            if(a[x][y] != b[i][j])
                return false;
        }
    }
    return true;
}
int sum(int a[][1001], int i0, int j0, int mr)
{
    int sum = 0;
    for(int x = 0; x < mr; ++x,++i0)
        sum += a[i0][j0];
    return sum;
}
int str_RK_2d(int a[][1001], int nr, int nc, int b[][51], int mr, int mc)//s是主串，t是模式串
{
    int i, j;
    ull hash_val, value;
    value = cal_hash_b(mr,mc,b);//计算2d模式串哈希值
    for(i = 0; i < nr-mr+1; ++i)//行最多nr-mr+1次比较
    {
        for(j = 0; j < nc-mc+1; ++j)//列最多nc-mc+1次比较
        {
            if(j == 0)
                hash_val = cal_hash_a_child(i,j,mr+i,mc+j,a);//计算2d子串哈希值
            else
                hash_val = ((hash_val-(sum(a,i,j,mr)<<(mc-1)))<<1) + sum(a,i,j+mc-1,mr);
            if(hash_val == value && same(a,b,i,j,mr,mc))
            {//如果2d子串哈希值等于模式串的，且"真的"字符串匹配（避免冲突带来的假匹配）
                return 1;
            }
        }
    }
    return 0;
}
void creatMatrix_a(int a[][1001], int r, int c)
{
    int i, j;
    char ch;
    for(i = 0; i < r; ++i)
        for(j = 0; j < c; ++j)
        {
            cin >> ch;
            if(ch == '*')
                a[i][j] = 1;
            else
                a[i][j] = 0;
        }
}
void creatMatrix_b(int b[][51], int r, int c)
{
    int i, j;
    char ch;
    for(i = 0; i < r; ++i)
        for(j = 0; j < c; ++j)
        {
            cin >> ch;
            if(ch == '*')
                b[i][j] = 1;
            else
                b[i][j] = 0;
        }
}
int main()
{
    int N, M, T, P, Q, count, ID = 1;
    while(cin >> N >> M >> T >> P >> Q && N)
    {
        count = 0;
        creatMatrix_a(a,N,M);
        while(T--)
        {
            creatMatrix_b(b,P,Q);
            count += str_RK_2d(a,N,M,b,P,Q);
        }
        cout << "Case " << ID++ << ": " << count << endl;
    }
    return 0;
}

2.3 Time Limit Exceeded 代码

改为计算每行的哈希值，把大矩阵的所有小矩阵的宽度的每行哈希值算出来，后面开始逐行比较，有不符合的，跳出，寻找下一个，还是超时

/**
 * @description: poj3690 2维矩阵匹配
 * @author: michael ming
 * @date: 2019/6/25 19:47
 * @modified by:
 */
#include <time.h>
#include <stdio.h>
typedef unsigned long long ull;
int a[1001][1001];
int b[51][51];
ull hash_b[51];//存放每行的哈希值，每行相当于一个2进制数
ull hash_a[1001][1001];//存放主串子串的哈希值

void cal_hash_b(int r, int c, int b[][51])
{
    int i, j, k;
    ull value;
    for (i = 0; i < r; ++i) //计算2d模式串的hash值value
    {
        value = 0;
        for(j = 0, k = c-1; j < c; ++j,--k)
        {
            value += b[i][j]<<k;
        }
        hash_b[i] = value;
    }
    return;
}
void cal_hash_a_child(int N, int M, int a[][1001], int P, int Q)
{
    int i, j, k, x;
    ull hash_value;
    for (i = 0; i < N; ++i) //计算2d子串的每行的hash值
    {
        for(j = 0; j < M-Q+1; ++j)
        {
            if(j == 0)
            {
                hash_value = 0;
                for(x = j, k = Q-1; x < j+Q && k >= 0; ++x,--k)
                    hash_value += a[i][x]<<k;
            }
            else
                hash_value = ((hash_a[i][j-1]-(a[i][j-1]<<(Q-1)))<<1)+a[i][j+Q-1];
            hash_a[i][j] = hash_value;
        }
    }
}

int str_RK_2d(int a[][1001], int N, int M, int b[][51], int P, int Q)//s是主串，t是模式串
{
    int i, j, k, x;
    bool flag = false;
    cal_hash_b(P,Q,b);//计算2d模式串每行哈希值
    for(j = 0; j < M-Q+1; ++j)//列最多nc-mc+1次比较,分别比较每行，列先固定
    {
        for(i = 0; i < N-P+1; ++i)
        {//行最多nr-mr+1次比较
            for(x = i, k = 0; x < i+P && k < P; ++x,++k)
            {//一组比较P行
                if(hash_a[x][j] == hash_b[k])//比较子串哈希值
                    flag = true;
                else
                {
                    flag = false;
                    break;
                }
            }
            if(flag == true)
                return 1;
        }
    }
    return 0;
}
void creatMatrix_a(int a[][1001], int r, int c)
{
    int i, j;
    char ch;
    for(i = 0; i < r; ++i)
        for(j = 0; j < c; ++j)
        {
            ch = getchar();
            while(ch == ' '||ch == '\n')
                ch = getchar();
            if(ch == '*')
                a[i][j] = 1;
            else
                a[i][j] = 0;
        }
}
void creatMatrix_b(int b[][51], int r, int c)
{
    int i, j;
    char ch;
    for(i = 0; i < r; ++i)
        for(j = 0; j < c; ++j)
        {
            ch = getchar();
            while(ch == ' '||ch == '\n')
                ch = getchar();
            if(ch == '*')
                b[i][j] = 1;
            else
                b[i][j] = 0;
        }
}
int main()
{
//    clock_t start, finish;
//    start = clock();
    int N, M, T, P, Q, count, ID = 1;
    while((scanf("%d%d%d%d%d",&N,&M,&T,&P,&Q)!=EOF) && N)
    {
        count = 0;
        creatMatrix_a(a,N,M);
        cal_hash_a_child(N,M,a,P,Q);
        while(T--)
        {
            creatMatrix_b(b,P,Q);
            count += str_RK_2d(a,N,M,b,P,Q);
        }
        printf("Case %d: %d\n",ID++,count);
    }
//    finish = clock();
//    cout << "takes "<< finish-start << " ms." << endl;
    return 0;
}
POJ3690 Constellations（二维Hash）
悲伤无声地涌出来
03-11 499
题目链接 Description The starry sky in the summer night is one of the most beautiful things on this planet. People imagine that some groups of stars in the sky form so-called constellations. Formally a ...
星座-POJ3690-详解
Patrick的博客
04-26 537
星座 给定一个由’*’和’0’组成的，大小为 N x M (N行M列)的匹配对象和 T个大小为 P x Q的匹配模式。 请输出在匹配对象中至少出现过一次的匹配模式的个数。 思路：这里要做的不是字符串匹配，而是二维网络匹配，同样可以运用循环哈希，首先把每一行看成一个字符串，计算从每个位置开始长度为Q的字符串子串的哈希值。然后再把得到的哈希值在列方向看成一个字符串，计算从每一个位置开始长度为P...
POJ3690 字符串哈希 星座
qq_41703679的博客
08-19 233
https://vjudge.net/contest/247319#problem/C 题目大意就是给出一个n * m的矩阵，矩阵中只有一些*或者0，n &lt;= 1000, m &lt;= 1000 然后有t (t &lt;= 100)个询问，每次询问给出一个p * q的矩阵，p,q是提前固定的数值。 问这些询问中是大矩阵的子矩阵的有几个   如果暴力查询，时间复杂度为t*n*m*p...
poj 3690（二维哈希）
Everything can be done!
09-05 447
感觉二维哈希的思想跟一维的差不多，比如要匹配的字符串是p *q的大小，先保存好以下标为i,j为一列的末尾元素的hash值，然后一q大小的列 进行 行的拓展，行列的思想都一样，滚动。 //#include #include #include #include #include using namespace std; typedef long long ll; typedef unsig
POJ3690：Constellations——题解
weixin_34319640的博客
12-09 146
http://poj.org/problem?id=3690 题目大意：给一个图和几个子图，判断有多少种子图在原图出现过。 —————————————————————— 二维哈希即可，操作看代码，我觉得蛮好看的。 注意这题恶心的时限。 pow预处理能少时间，读入字符用getchar不然会TLE。 用multiset查找然后再一个个erase即可，这样set前后size的差值即是答案。 ...
poj openjudge 1111最大正向匹配
04-20
### poj openjudge 1111 最大正向匹配题目解析与解答 #### 题目背景 在算法竞赛和编程挑战中，字符串处理是非常常见的一类问题。本题（poj openjudge 1111）即为一个典型的字符串处理题目，要求找到一系列输入字符...
POJ1852题目和详细解答
02-05
POJ1852题目详解 POJ1852题目是一道关于计算最早和最晚可能时间的题目，问题描述如下：有一根长度为L厘米的水平竿，每个蚂蚁以1厘米/秒的速度移动。当蚂蚁走到竿子的一端时，它会立刻掉下去。当两个蚂蚁相遇时，...
POJ_3131.zip_POJ 八数码_poj
09-20
标题中的“POJ_3131.zip_POJ 八数码_poj”指的是一个与编程竞赛网站POJ（Problem Set Algorithm）相关的项目，具体是针对3131号问题的解决方案，该问题涉及到了八数码游戏。八数码游戏，又称滑动拼图，是一个经典的...
POJ.rar_poj java_poj1048
09-24
【标题】"POJ.rar_poj java_poj1048" 涉及的知识点主要围绕编程竞赛中的“约瑟夫环”问题，这里是一个加强版，使用Java语言进行解决。 【描述】"POJ1048，加强版的约瑟夫问题 难度中等" 提示我们，这个问题是编程...
jihe.rar_2289_POJ 3714_poj3714_poj3714 Ra_visual c
09-22
标题中的"jihe.rar_2289_POJ 3714_poj3714_poj3714 Ra_visual c" 提到了一个压缩文件，可能包含有关编程竞赛或算法解决的资源，特别是与POJ（Problem On Judge）平台上的问题3714相关的。"Ra_visual c"可能指的是...
POJ3690 Constellations 【KMP】
长风的专栏
07-18 1402
Constellations Time Limit: 3000MS   Memory Limit: 65536K Total Submissions: 5044   Accepted: 983 Description The starry sky in the summer night is one of the most beaut
寻找星座 题解
linweitong2020的博客
06-07 228
寻找星座 题解 题目 在这里。 解题方法 这道题的方法是暴力。 我们选取一个标准进行尝试就行了，每一次看一看这个标准和是否满足其他的星座，如果符合就输出。
POJ 3690 Constellations + Gym - 100783J The Big Painting 二维字符串hash
GeN的博客
08-29 554
这次组队赛也出现了同样的题目，然而不会做。所以来学习一波新姿势。 二维字符串hash的原理就是先把行横着做普通的一位字符串hash，然后每一行都有一个hash值，再竖着将行与行的hash值再hash一次。原理并不复杂。然后注意横着和竖着hash取两个不同的大质数就可以了。 把x1x1 , 当做横着hash的质数，x2x2 当做竖着hash的质数。 对于这题来说。 r[i][j] 表示横着h
poj3690(哈希字符串匹配）
qq_39861441的博客
02-25 341
解题思路：这道题就是给定一个二维的矩阵(n*m)，然后给几个小矩阵（p*q）去进行匹配。那我们就可以看成是一个p*q&lt;2500的字符串匹配。所以可以用hash.接下来就是传统的hash字符串匹配了。kmp是肯定不行的，因为是多字符串匹配。题比较基础，代码以后再写吧，先占个坑。...
Constellations POJ - 3690 (Rabin-Karp算法)
肘子的博客
09-20 267
传送门 题解：这里是二维网格的匹配，运用循环哈希，首先把每一行看成一个字符串，计算从每个位置开始长度为Q的字符串子串的哈希值。然后把得到的哈希值在列方向上看成一个字符串，计算每个位置开始长度为P的字符串子串的哈希值。这样，高效地计算得到了所有的P*Q的子阵的哈希值。在两次哈希值的计算中，选用不同的基数。 附上代码： #include&lt;iostream&gt; #include&lt;...
1397. 寻找星座
蒟蒻こんにゃく
06-13 832
1397. 寻找星座 题目描述 现在你在一张卫星图片中寻找星座，已知该星座在图片中正好出现一次，而且形状一样，方向一样，大小也一样。注意图片中可能有一些与该星座无关的星星。 例如图1中的星座出现在图2的卫星图片中（用圆圈标识部分）。图1中给定的星座需要在X轴上平移2个单位同时在y轴上平移-3个单位才能与卫星图片中的卫星正好吻合。 写一个程序，计算给定星座的星星需要在X和Y方向上分别平移多少单位才能与卫星图片吻合。 输入 第1行：一个整数M，表示需要寻找的星座中星星的数量； 第2…M+1行：每行两个用空格隔
POJ 3690 Constellations 简单hash
水
09-16 2344
题目大意就是给出一个n * m的矩阵，矩阵中只有一些*或者0 n 然后有t (t p,q是提前固定的数值。 问这些询问中能是大矩阵的子矩阵的有几个 由于p , q都小于50，而且矩阵中只有两个字符 不由得让我们联想到了，把每一行给hash成一个long long 的二进制数 首先，我们把大矩阵每个位置为起点的q长度的串hash成二进制数都存起来 每次询问的时候，把小矩阵
poj 3690 Constellations 矩阵的hash
08-27 1085
给定一个n*m矩阵和t个p*q的矩阵，求这t个矩阵有多少个是n*m的子矩阵。 矩阵都是01矩阵，只有'0' '*' 矩阵的hash，先将每行q列hash，得到一个新矩阵，然后再每列p行hash 【注意行列hash时候取的magic数不能一样，不然很容易冲突，会WA，最好取2个素数】 这样原矩阵的每个子矩阵都由一个数字代替了，之后用map判断就够了。 注意：不能事先将原矩阵的所有子矩阵h
poj 3690 Constellations 二维滚动哈希匹配
sepNINE的专栏
10-15 673
//poj 3690 //sep9 #include #include using namespace std; typedef unsigned long long ull; const int MAXN=1024; const int MAXT=128; const int MAXP=64; const int B1=9973; const int B2=100000007; char
Poj3254详细解答与注释
2. 动态规划题解：若Poj3254是一个动态规划问题，解决它的关键在于定义状态、找出状态转移方程以及确定初始条件。例如，在背包问题中，状态可能是“当前背包容量为w时，能够装载的最大价值”，状态转移方程可能是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Michael阿明

如果可以，请点赞留言支持我哦！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值