51nod 1753 相似子串

最新推荐文章于 2022-02-05 21:10:55 发布
最新推荐文章于 2022-02-05 21:10:55 发布
阅读量875 收藏
点赞数 1
分类专栏： 哈希 刷题小结 文章标签： hash
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZLH_HHHH/article/details/77898235
版权

51nod 1753 相似子串

原题链接：
https://www.51nod.com/onlineJudge/questionCode.html#!problemId=1753

很少写字符串hash的题目。这算是第一个啦

对字符单独考虑。

考虑字符串的 hash

定义 A[k][i] ：

A[k][i]=[s[i]=k]

对于一个 01 串 s ，定义它的hash值为：

h(s)=∑i=1|s|s[i]bi  mod P,P为素数

为了避免冲突。多次 hash

那么对于等价的字符形成的 01 串的 hash 值是可以直接相加的

因为一个字符只可能属于一个 A[k][] 。

hash 值其实是一个 b 进制数.所以不会出现某一位数字超过1

那么如果有 s1 , s2 有一位不同时:
hash(s1)−hash(s2)=Pk

直接查询即可。

#include <algorithm>
#include <string.h>
#include <stdio.h>
#include <cmath>
#define MAXN 300005

using namespace std;
typedef long long LL;
const char ll='0'-1;
const char rr='9'+1;
struct Io
{
    char A[MAXN];
    char *Pb=A,*Pe=A;
    void Io_fread()
    {
        Pb=A;
        Pe=A+fread(A,1,MAXN,stdin);
    }
    void s_read(char *s)
    {
        if(Pb==Pe)Io_fread();
        if(Pb==Pe)return ;
        while(*Pb=='\n'||*Pb=='\r'||*Pb==' ')
        {
            Pb++;
            if(Pb==Pe)
            {
                Io_fread();
                if(Pb==Pe)return ;
            }
        }

        while(*Pb!='\n'&&*Pb!='\r')
        {
            *s=*Pb;
            s++;
            Pb++;
            if(Pb==Pe)
            {
                Io_fread();
                if(Pb==Pe)
                {
                    *s=0;
                    return;
                }
            }
        }
        *s=0;
    }
    char c_read()//读取一个字符 不读 空格换行
    {
        if(Pb==Pe)Io_fread();
        if(Pb==Pe)return -1;
        while(*Pb=='\n'||*Pb=='\r'||*Pb==' ')
        {
            Pb++;
            if(Pb==Pe)
            {
                Io_fread();
                if(Pb==Pe)return -1;
            }
        }
        return *(Pb++);
    }
    int read()
    {
        int tmp=0;
        if(Pb==Pe)Io_fread();
        if(Pb==Pe)return -1;
        while(*Pb=='\n'||*Pb=='\r'||*Pb==' ')
        {
            Pb++;
            if(Pb==Pe)
            {
                Io_fread();
                if(Pb==Pe)return -1;
            }
        }
       while(*Pb>ll&&*Pb<rr)
       {
           tmp=tmp*10+(*Pb-'0');
           Pb++;
           if(Pb==Pe)
           {
               Io_fread();
               if(Pe==Pb)return tmp;
           }
       }
        return tmp;
    }
}I;
const int P1=998244353;
const int P2=985661441;
const int P3=1e8+7;
const LL base=1e9+7;
struct HasH
{
    int k1,k2,k3;
    HasH(int k1,int k2,int k3):k1(k1),k2(k2),k3(k3){}
    HasH()
    {
        k1=k2=k3=0;
    }
    bool operator ==(const HasH&a)const
    {
        return k1==a.k1&&k2==a.k2&&k3==a.k3;
    }
    HasH operator +(const HasH &a)const
    {
        return HasH((k1+a.k1)%P1,(k2+a.k2)%P2,(k3+a.k3)%P3);
    }
    HasH operator -(const HasH &a)const
    {
        return HasH((k1-a.k1+P1)%P1,(k2-a.k2+P2)%P2,(k3-a.k3+P3)%P3);
    }
}H[26][MAXN];
struct node
{
    int k,d;
    node(int k,int d):k(k),d(d){};
    node()
    {
        *this=node(0,-1);
    }
    bool operator <(const node &a)const
    {
        if(k!=a.k)return k<a.k;
        return d<a.d;
    }
    bool operator ==(const node &a)const
    {
        return d==a.d;
    }
}B[3][MAXN];
int Pow(int a,int b,int mod)
{
    LL tmp=1;
    while(b)
    {
        if(b&1)
            tmp=tmp*a%mod;
        a=(LL)a*a%mod;
        b>>=1;
    }
    return (int)tmp;
}
int Iv[3][MAXN];
int po[3][MAXN];
void init()
{
    po[0][0]=po[1][0]=po[2][0]=1;
    for(int i=0;i<MAXN;i++)
    {
        B[0][i]=node(po[0][i],i);
        B[1][i]=node(po[1][i],i);
        B[2][i]=node(po[2][i],i);
        Iv[0][i]=Pow(po[0][i],P1-2,P1);
        Iv[1][i]=Pow(po[1][i],P2-2,P2);
        Iv[2][i]=Pow(po[2][i],P3-2,P3);
        if(i+1<MAXN)po[0][i+1]=base*po[0][i]%P1;
        if(i+1<MAXN)po[1][i+1]=base*po[1][i]%P2;
        if(i+1<MAXN)po[2][i+1]=base*po[2][i]%P3;
    }
    sort(B[0],B[0]+MAXN);
    sort(B[1],B[1]+MAXN);
    sort(B[2],B[2]+MAXN);
}
struct Bf
{
    int A[26];
    void clear()
    {
        for(int i=0;i<26;i++)A[i]=i;
    }
    Bf()
    {
        clear();
    }
    int find(int a)
    {
        if(a==A[a])return a;
        return A[a]=find(A[a]);
    }
    void merg(int a,int b)
    {
        a=find(a);
        b=find(b);
        A[a]=b;
    }
}F;
char s[MAXN];
bool vis[26];
HasH used[2][26];
int camp(int b)
{
    int k1=(P1+used[0][b].k1-used[1][b].k1)%P1;
    int k2=(P2+used[0][b].k2-used[1][b].k2)%P2;
    int k3=(P3+used[0][b].k3-used[1][b].k3)%P3;
    int d1=(int)(lower_bound(B[0],B[0]+MAXN,node(k1,-1))-B[0]);
    if(d1<MAXN&&B[0][d1].k==k1)
    {
        for(int j=d1;j<MAXN&&B[0][j].k==B[0][d1].k;j++)
        {
            int d=(int)(lower_bound(B[1],B[1]+MAXN,node(k2,B[0][j].d))-B[1]);
            if(d>=MAXN||B[1][d].k!=k2||!(B[0][j]==B[1][d]))continue;
            d=(int)(lower_bound(B[2],B[2]+MAXN,node(k3,B[0][j].d))-B[2]);
            if(d>=MAXN||B[2][d].k!=k3||!(B[0][j]==B[2][d]))continue;
            return 1;
        }
    }
    k1=(P1-k1)%P1;
    k2=(P2-k2)%P2;
    k3=(P3-k3)%P3;
    d1=(int)(lower_bound(B[0],B[0]+MAXN,node(k1,-1))-B[0]);
    if(d1<MAXN&&B[0][d1].k==k1)
    {
        for(int j=d1;j<MAXN&&B[0][j].k==B[0][d1].k;j++)
        {
            int d=(int)(lower_bound(B[1],B[1]+MAXN,node(k2,B[0][j].d))-B[1]);
            if(d>=MAXN||B[1][d].k!=k2||!(B[0][j]==B[1][d]))continue;
            d=(int)(lower_bound(B[2],B[2]+MAXN,node(k3,B[0][j].d))-B[2]);
            if(d>=MAXN||B[2][d].k!=k3||!(B[0][j]==B[2][d]))continue;
            return 1;
        }
    }
    return 3;
}
int main ()
{
    init();
    I.s_read(s+1);
    for(int i=0;i<26;i++)
    {
        for(int j=1;s[j];j++)
        {
            if(s[j]-'a'==i)
                H[i][j]=HasH(po[0][j],po[1][j],po[2][j]);
            H[i][j]=H[i][j-1]+H[i][j];
        }
    }
    int t,k,l1,l2,r1,r2;
    char a,b;
    t=I.read();
    while(t--)
    {
        F.clear();
        memset(vis,0,sizeof vis);
        for(int i=0;i<26;i++)used[0][i]=used[1][i]=HasH(0,0,0);
        k=I.read();
        l1=I.read();
        r1=I.read();
        l2=I.read();
        r2=I.read();
        for(int i=0;i<k;i++)
        {
            a=I.c_read();
            b=I.c_read();
            F.merg(a-'a',b-'a');
        }
        if(r1-l1!=r2-l2)
        {
            printf("NO\n");
            continue;
        }
        for(int i=0;i<26;i++)
        {
            int u=F.find(i);
            used[0][u]=used[0][u]+H[i][r1]-H[i][l1-1];
            used[1][u]=used[1][u]+H[i][r2]-H[i][l2-1];
        }
        int flag=0;
        for(int u=0;u<26;u++)
        {
            int i=F.find(u);
            if(vis[i])continue;
            vis[i]=true;
            LL I1=Iv[0][l1-1];
            LL I2=Iv[1][l1-1];
            LL I3=Iv[2][l1-1];
            used[0][i].k1=I1*used[0][i].k1%P1;
            used[0][i].k2=I2*used[0][i].k2%P2;
            used[0][i].k3=I3*used[0][i].k3%P3;
            I1=Iv[0][l2-1];
            I2=Iv[1][l2-1];
            I3=Iv[2][l2-1];
            used[1][i].k1=I1*used[1][i].k1%P1;
            used[1][i].k2=I2*used[1][i].k2%P2;
            used[1][i].k3=I3*used[1][i].k3%P3;
            if(used[0][i]==used[1][i])continue;
            flag+=camp(i);
            if(flag>2)break;
        }
        if(flag<3)
            printf("YES\n");
        else
            printf("NO\n");
    }
}
佐理慧
关注
专栏目录
51nod P3050 2维切方格【数学】
JA_yichao欢迎你 cnblogs账号：https://www.cnblogs.com/mayichao/
02-26 328
数学
【51nod】【map】子集和判断
Y的博客
01-17 284
【51nod】【map】子集和判断 题目 解题思路 将A和B中的数作为map的下标，存储出现的次数 用A的数和B比较，如果出现次数比B多或是出现B中没有的，输出NO，否则输出YES 代码 #include<iostream> #include<cstdio> #include<map> using namespace std; map<int, int>::iterator w; map<int,int> lzf,yty; int n,m
51Nod-1753-相似子串
逐梦者
09-13 412
ACM模版描述题解字符串哈希问题，代码小长……给大家贴一下我佐学姐题解以及他的代码吧……好崇拜学姐。代码#include <algorithm> #include <cstring> #include <cstdio> #include <cmath>using namespace std;const int MAXN = 3e5 + 10;typedef long long ll;const ch
【51Nod1753】相似子串
wang_sj的博客
09-24 411
两个字符串相似定义为： 1.两个字符串长度相等 2.两个字符串对应位置上有且仅有至多一个位置所对应的字符不相同 给定一个字符串，每次询问两个子串在给定的规则下是否相似。给定的规则指每次给出一些等价关系，如‘a’=’b’，‘b’=’c’等，注意这里的等价关系具有传递性，即若‘a’=’b’，‘b’=’c’，则‘a’=’c’。 Input 第一行一个字符串s(1<=|s|<=300000) 第
51Nod 1753 相似子串
weixin_30316097的博客
09-20 105
题目大意: 两个字符串相似定义为： 1.两个字符串长度相等 2.两个字符串对应位置上有且仅有至多一个位置所对应的字符不相同 给定一个字符串，每次询问两个子串在给定的规则下是否相似。给定的规则指每次给出一些等价关系，如‘a'=’b'，‘b'=’c'等，注意这里的等价关系具有传递性，即若‘a'=’b'，‘b'=’c'，则‘a'=’c'。 解题报告: 正解:哈希+二分 我们先处理出每一个字母哈希值的前缀...
相似子串
brucehb的专栏
06-24 557
两个字符串相似定义为：1.两个字符串长度相等2.两个字符串对应位置上有且仅有至多一个位置所对应的字符不相同给定一个字符串，每次询问两个子串在给定的规则下是否相似。给定的规则指每次给出一些等价关系，如‘a'=’b'，‘b'=’c'等，注意这里的等价关系具有传递性，即若‘a'=’b'，‘b'=’c'，则‘a'=’c'。Input第一行一个字符串s(1&lt;=|s|&lt;=300000) 第二行一个...
bzoj3230: 相似子串
weixin_34292402的博客
12-25 97
后缀数组找本质不同第k大子串：考虑属于每个后缀的自己的子串（这个子串的第一个出现位置） 后缀排序，每个后缀贡献的右端点是[height[i]+1, len[i]]，而且后缀的顺序走下去，在走每个后缀的子串，恰好就是字典序的顺序 二分位置，找到长度，建反串，lcp找找即可。 转载于:https://www.cnblogs.com/Miracevin/p/10176533.html...
51nod:51nod.com的代码
05-03
51点 51nod.com的代码
leetcodeoj和leetcode-My51Nod:个人题解（画风和leetcode不一样的OJ网站）
07-07
【标题】 "LeetCode OJ和LeetCode-My51Nod:个人题解与开源系统解析" 在编程世界中，LeetCode是一个广受欢迎的在线编程挑战平台，它提供了丰富的算法题目供程序员们练习和提升自己的技能。LeetCode OJ（Online Judge...
最长配对（51Nod-2494）.rar
09-16
标题中的“最长配对（51Nod-2494）”可能指的是一个编程竞赛题目或算法问题，源自51Nod这个在线编程训练平台的第2494个问题。51Nod是一个为程序员提供算法练习的网站，其中的题目涵盖了许多常见的数据结构和算法知识...
[BZOJ 3230]相似子串
weixin_30339457的博客
03-26 103
[BZOJ 3230]相似子串 题意 给定一个长度为 \(n\) 的字符串以及 \(q\) 组查询, 每组查询给定 \(a\) 和 \(b\), 求在所有本质不同子串中排名第 \(a\) 和第 \(b\) 的串的最长公共前缀与最长公共后缀的平方和. \(n,q\le 1\times 10^5\). 题解 后缀数组板子题.麻麻我终于会用后缀数组辣 本来想接着用SAM的...但是发现多组查询...
[BZOJ3230]相似子串
weixin_30344795的博客
03-09 54
[BZOJ3230]相似子串 试题描述 输入 输入第1行，包含3个整数N，Q。Q代表询问组数。第2行是字符串S。接下来Q行，每行两个整数i和j。（1≤i≤j）。 输出 输出共Q行，每行一个数表示每组询问的答案。如果不存在第i个子串或第j个子串，则输出-1。 输入示例 5 3 ababa 3 5 5 9 8 10 输出示例 18 16 ...
BZOJ 3230: 相似子串
aisen1985的博客
03-29 109
Description 求本质不同的子串排名为\(i,j\)的两个子串最长公共前缀和最长公共后缀的平方。\(n\leqslant 10^5,q\leqslant 10^5\) Solution 后缀数组+ST表。 本质不同的子串可以用过\(n-sa[i]+1-ht[i]\)得到一个后缀的本质不同后缀的贡献。 然后统计出来前缀和，在上面二分就可以得到位置和长度。 最长公共前缀就...
3230: 相似子串
ailiao2015的博客
06-02 114
Description Input 输入第1行，包含3个整数N，Q。Q代表询问组数。第2行是字符串S。接下来Q行，每行两个整数i和j。（1≤i≤j）。 Output 输出共Q行，每行一个数表示每组询问的答案。如果不存在第i个子串或第j个子串，则输出-1。 Sample Input 5 3 ababa 3 5 ...
BZOJ3230 相似子串
KuribohG
01-03 1275
这个题思路应该算是比较简单的…… 先扫一遍height，算出前i个后缀中含有的不同子串个数，然后在这个和中二分，找到一个排名对应的子串。 然后就是最长公共前缀和最长公共后缀……用两个后缀数组即可完成所有操作。 但是我有两个之前写错了的地方： 1、没有开long long 2、注意算LCP的时候，要算RMQ(rank[p]+1,rank[q])，但如果rank[p],rank[q]大小关系
YbtOJ-相似子串【SA,RMQ,二分】
QuantAsk
02-05 496
正题 题目大意 给出一个长度为nnn的字符串，两个串相似当且仅当可以通过每种字符置换使得它们相同。 qqq次询问这个字符串所有子串中和这个串中sl,rs_{l,r}sl,r​子串有多少个相似的。 1≤n≤105,1≤q≤5×1051\leq n\leq 10^5,1\leq q\leq 5\times 10^51≤n≤105,1≤q≤5×105 字符集是数字0∼90\sim 90∼9 解题思路 请问我是在阴间吗 首先对于相似的比较相信很常见，维护每个数字上一个和它相同的数字的距离，然后没有上一个就定为
BJ模拟 相似子串【哈希+并查集】
cdsszjj的博客
04-21 223
题目描述： 解题思路： 把26个字母分开hash,每一位只用0和1表示这一位是否是字母i。 询问时也把26个字母分开比较，把等价类里的hash加起来算。 不同处最多为1，即是最后的hash值只会有一个形如baseibaseibase^i的差，判断一下即可。 #include&lt;bits/stdc++.h&gt; #define ll unsigned long long ...
bzoj 3230 相似子串
我要吃熊猫
05-07 466
二分+RMQ+后缀数组
【bzoj3230】相似子串
weixin_30695195的博客
07-17 84
Portal -->bzoj3230 Description 　　给你一个长度为\(n\)的字符串，把它的所有本质不同的子串按字典序大小排序，有\(m\)个询问，对于每一个询问\(x,y\)你需要回答排名\(x\)和子串和排名\(y\)的子串的最长公共前缀的平方和+最长公共后缀的平方和，如果询问不合法输出\(-1\) 　　数据范围：\(n<=10^5,m<=10^5\)，字符串只...
51nod3204分数运算
最新发布
07-09
对于题目51nod3204，这是一个分数运算的问题。很抱歉，由于我无法直接访问外部网站或查找特定问题的详细答案，我不能为你提供该问题的具体解答。然而，我可以为您提供一般的分数运算知识和算法，以帮助您解决该问题...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值