ACWing算法基础课刷题记录2024-06-01--2day

小白2109

已于 2024-06-01 21:59:30 修改

阅读量544

点赞数 9

分类专栏：排序文章标签：算法数据结构

于 2024-06-01 21:56:35 首次发布

本文链接：https://blog.csdn.net/m0_62059957/article/details/139378795

版权

排序专栏收录该内容

6 篇文章 0 订阅

订阅专栏

831. KMP字符串

给定一个字符串 S𝑆，以及一个模式串 P𝑃，所有字符串中只包含大小写英文字母以及阿拉伯数字。

模式串 P𝑃 在字符串 S𝑆 中多次作为子串出现。

求出模式串 P𝑃 在字符串 S𝑆 中所有出现的位置的起始下标。

输入格式

第一行输入整数 N𝑁，表示字符串 P𝑃 的长度。

第二行输入字符串 P𝑃。

第三行输入整数 M𝑀，表示字符串 S𝑆 的长度。

第四行输入字符串 S𝑆。

输出格式

共一行，输出所有出现位置的起始下标（下标从 00 开始计数），整数之间用空格隔开。

数据范围

1≤N≤1051≤𝑁≤105
1≤M≤1061≤𝑀≤106

输入样例：

3
aba
5
ababa

输出样例：

0 2

解题思路
暴力算法，每次移动一个字符，时间限制，比较费力

KMP算法

s1：计算前缀

s2: 找最长前后缀数组next

s3: 匹配

#include <bits/stdc++.h>
using namespace std;
const int N = 100010, M = 1000010;
char p[N], s[M];
int n, m,  next1[N], f[N];
int main() {
//数组都是从下标1开始的
    cin >> n >> p + 1 >> m >> s + 1;

//求next的过程
for(int i=2,j=0;i<=n;i++){
    while(j!=0&&p[i]!=p[j+1])j=next1[j];
/*
寻找一个最长的后缀，它同时也是某个前缀。当p[i]不等于p[j+1]时，说明当前匹配的前缀-后缀不满足条件，需要缩短前缀长度，将j更新为nxt[j]，即当前前缀的失效函数值。
*/
    if(p[i]==p[j+1]) j++;//当前字符与前缀的下一个字符匹配，则增加j的值，即增加前缀的长度
    next1[i]=j;/*将计算出的j值赋给nxt[i]，表示当p[i]处的字符不匹配时，模式应该向右滑动到j的位置*/
}

    //kmp匹配过程
    for (int i = 1, j = 0; i <= m; i++) {
        while (j && s[i] != p[j + 1]) j = next1[j];
/*这个循环用于处理不匹配的情况，当j不为0且当前文本字符s[i]与模式中的下一个字符p[j + 1]不匹配时，将j更新为next1[j]，即模式向右滑动的位数
*/
        if (s[i] == p[j + 1]) j++;
/*
如果当前文本字符与模式中的下一个字符匹配，则增加j的值，表示模式的前缀长度增加。
*/
        if (j == n) {//j=p的长度n，模式p完全匹配了文本s中的一部分，即从s[i-n+1]开始的子串
            //匹配成功了
            cout<< i - n<<" ";
            j =  next1[j];//这一步和匹配的第一步相同，找最长前后缀
        }
    }
    return 0;
}

看到一篇很好的文章

从头到尾彻底理解KMP（2014年8月22日版）_kmp算法 csdn-CSDN博客

835. Trie字符串统计

维护一个字符串集合，支持两种操作：

I x 向集合中插入一个字符串 x𝑥；
Q x 询问一个字符串在集合中出现了多少次。

共有 N𝑁 个操作，所有输入的字符串总长度不超过 105105，字符串仅包含小写英文字母。

输入格式

第一行包含整数 N𝑁，表示操作数。

接下来 N𝑁 行，每行包含一个操作指令，指令为 I x 或 Q x 中的一种。

输出格式

对于每个询问指令 Q x，都要输出一个整数作为结果，表示 x𝑥 在集合中出现的次数。

每个结果占一行。

数据范围

1≤N≤2∗1041≤𝑁≤2∗104

输入样例：

5
I abc
Q abc
Q ab
I ab
Q ab

输出样例：

1
0
1

/*最开始思路：一个字符串数组，vector<string>,I操作就是在字符串后面新插入字符串
Q操作，查找这个字符串在不在数组str，用find函数,在查找时，发现比较费时间，不只是查找是否存在，
还需要返回次数。所以我们使用一个unordered_map来维护字符串及其出现的次数。每次插入操作I x时，
我们就在unordered_map中增加字符串x的计数。每次查询操作Q x时，我们输出字符串x的当前计数
*/
//unordered_map的底层实现是哈希表，因此插入和查询操作的平均时间复杂度都是O(1)，这足以满足数据范围的要求
//实现字符串计数的一种高效方式，可以快速处理大量的插入和查询操作
#include<bits/stdc++.h>
using namespace std;
 unordered_map<string, int> counts;
int m;
int main(){
    cin>>m;
    char a;
    string s;
    for (int i = 0; i < m; ++i) {
        cin >> a >> s;
        if (a == 'I') {
            counts[s]++;
            /*
            如果s已经存在于unordered_map中，则将其对应的值加1。
            如果s不在unordered_map中，则将其添加到unordered_map中，并将其对应的值设置为1。*/
        } else if (a == 'Q') {
            cout << counts[s] << endl;
        }
    }
    return 0;
}

不过这个题是一个典型的tries树的题，模板题

143. 最大异或对

在给定的 N𝑁 个整数 A1，A2……AN𝐴1，𝐴2……𝐴𝑁 中选出两个进行 xor𝑥𝑜𝑟（异或）运算，得到的结果最大是多少？

输入格式

第一行输入一个整数 N𝑁。

第二行输入 N𝑁 个整数 A1𝐴1～AN𝐴𝑁。

输出格式

输出一个整数表示答案。

数据范围

1≤N≤1051≤𝑁≤105,
0≤Ai<2310≤𝐴𝑖<231

输入样例：

3
1 2 3

输出样例：


//Trie树快速存储字符集合和快速查询字符集合
#include <iostream>
using namespace std;
const int N = 100010;
//son[][]存储子节点的位置，分支最多26条；
//cnt[]存储以某节点结尾的字符串个数（同时也起标记作用）
//idx表示当前要插入的节点是第几个,每创建一个节点值+1
int son[N][26], cnt[N], idx;
char str[N];

void insert(char *str)
{
    int p = 0;  //类似指针，指向当前节点
    for(int i = 0; str[i]; i++)
    {
        int u = str[i] - 'a'; //将字母转化为数字，树的根节点是0，其他的字母，减去小写字母之后，最多有25个，0-25，就是第一层树，可以包括a-z
        if(!son[p][u]) son[p][u] = ++idx;   //该节点不存在，创建节点
        p = son[p][u];  //使“p指针”指向下一个节点，如果说这个节点是存在的，那就只指向这个节点
    }
    cnt[p]++;  //结束时的标记，也是记录以此节点结束的字符串个数
}

int Que(char *str)
{
    int p = 0;
    for(int i = 0; str[i]; i++)
    {
        int u = str[i] - 'a';
        if(!son[p][u]) return 0;  //该节点不存在，即该字符串不存在
        p = son[p][u]; 
    }
    return cnt[p];  //返回字符串出现的次数
}

int main()
{
    int m;
    cin >> m;

    while(m--)
    {
        char a;
        cin>>a>>str;

        if(a == 'I') insert(str);
         else cout<< Que(str)<<endl;
    }

    return 0;
}

两种方式运行时间相差不大

//这个题一开始是没有思路的，一点思路都没有，参考了评论区解题思路
#include<bits/stdc++.h>
using namespace std;
int const N=100010,M=31*N;
int n;
int a[N];
int son[M][2],idx;
//M最大可以创建多少条路
void insert(int x)//这一步和上一个插入是一样的操作
{
    int p=0;  //根节点
    for(int i=30;i>=0;i--)
    {
        int u=x>>i&1;   /取X的第i位的二进制数是什么  x>>k&1(前面的模板)
        if(!son[p][u]) son[p][u]=++idx; ///如果插入中发现没有该子节点,开出这条路
        p=son[p][u]; //指针指向下一层
    }
}
int find(int x)//查找xor
/*
 // 对于当前位的二进制数
        // 尽可能往其出现过的相反的方向走，假设当前位 u = 0
        // 若1的那个方向的 trie树枝干被创建则向那个方向走
        // 若没有被创建，则先将就一下走0的方向
*/
{
    int p=0;int res=0;
    for(int i=30;i>=0;i--)
    {                               ///从最大位开始找
        int u=x>>i&1;
        if(son[p][!u]) 如果当前层有对应的不相同的数
        {   ///p指针就指到不同数的地址

          p=son[p][!u];
          res=res*2+1;
        }                                              
        else    
        {
            p=son[p][u];
            res=res*2+0;
        }
    }
    return res;
}
int main(void)
{
    cin.tie(0);//初始化根节点
    cin>>n;
    idx=0;
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
        insert(a[i]);
    }
    int res=0;
    for(int i=0;i<n;i++)
    {   
        res=max(res,find(a[i])); 
    }
    cout<<res<<endl;
}

小白2109

关注

9
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
ACWing算法基础课刷题记录2024-06-01--2day

831. KMP字符串给定一个字符串 S𝑆，以及一个模式串 P𝑃，所有字符串中只包含大小写英文字母以及阿拉伯数字。模式串 P𝑃 在字符串 S𝑆 中多次作为子串出现。求出模式串 P𝑃 在字符串 S𝑆 中所有出现的位置的起始下标。
复制链接

扫一扫