数据结构-KMP、Trie树、并查集-C++实现

数据结构-KMP、Trie树、并查集-C++实现

算法基本思想及步骤：

KMP：子字符串与母字符串匹配，重点在于对子字符串中的最长公共前后缀长度的运用，减少匹配字符串时的操作次数

Trie树：
1.向集合中插入字符串：将单个字符转化为数字存储在数组中，创建树，标记每个字符串结尾的地方
2.询问集合中是否存在字符串：依次匹配，判断最后停下的位置处有没有标记

并查集：
1、将集合以树的形式存储，设定用每个树的根节点代表这个集合的编号，p[x]存储集合中x的父节点，只有根节点的父节点是它自己，即p[x]=x时说明找到了根节点
2、两种应用：
（1）合并两个集合：直接连接两个集合的根节点（即对于以x和y为根节点的两个集合，让p[x] = y）
（2）询问两个点是否在同一个集合内：即查找两个点的根节点是否为一个点
3、优化（路径压缩）：在查找一个点的根节点的时候，让过程中所有的点的父亲节点直接指向根节点

AcWing题库-831-KMP字符串

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

模板串P在模式串S中多次作为子串出现。

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

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

第二行输入字符串P。

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

第四行输入字符串S。

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

数据范围
1≤N≤105
1≤M≤106
输入样例：
3
aba
5
ababa
输出样例：
0 2

题目解析：
字符串匹配的暴力方法是分别遍历子字符串和母字符串，从字符串s的每一位向后依次判断当前位置是否存在与字符串p匹配的子串，KMP使用p字符串的一个next数组来减少不必要的遍历次数，这里next数组的定义如下：

在依次遍历字符串时，当s[i]与p[j+1]不匹配时，需要把p向后移动，因为已知p中以j结尾的子串的最长公共前后缀长度为next[j]，所以可以知道s字符串中[i - next[j], i - 1]区间内子串与p字符串中[1,next[j]]区间内的子串一定是相等的，所以不用再判断这部分，直接让j回退到next[j]再继续判断s[i]与p[j+1]是否相等即可，图解如下：

代码

#include<iostream>

using namespace std;

const int N = 100010, M = 1000010;

int n, m, ne[N];
char p[N], s[M];

int main()
{
    cin >> n >> p + 1 >> m >> s + 1;  //从下标为1开始
    
    for (int i = 2, j = 0; i <= n; i++)  //求p字符串中子串的最长公共前后缀
    {
        while (j && p[i] != p[j + 1]) j = ne[j];
        if (p[i] == p[j + 1]) j++;
        ne[i] = j;
    }
    
    for (int i = 1, j = 0; i <= m; i++)
    {
        while (j && s[i] != p[j + 1]) j = ne[j];  //不匹配时j回退
        if (s[i] == p[j + 1]) j++;  //匹配成功向后继续匹配
        if (j == n)  //找到子串，输出，j回退继续后面的匹配
        {
            cout << i - n << ' ';
            j = ne[j];
        }
    }
    
    return 0;
}

AcWing题库-835-Trie字符串统计

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

“I x”向集合中插入一个字符串x；
“Q x”询问一个字符串在集合中出现了多少次。
共有N个操作，输入的字符串总长度不超过 105，字符串仅包含小写英文字母。

输入格式
第一行包含整数N，表示操作数。

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

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

每个结果占一行。

数据范围
1≤N≤2∗104
输入样例：
5
I abc
Q abc
Q ab
I ab
Q ab
输出样例：
1
0
1

代码

#include <iostream>

using namespace std;

const int N = 100010;

int son[N][26], cnt[N], idx; //英文字母一共26个，作为数组长度存入son数组中，例如'a'对应0， 'b'对应1
char str[N];

void insert(char *str)  //插入字符串
{
    int p = 0;
    for (int i = 0; str[i]; i++)
    {
        int u = str[i] - 'a';
        if (!son[p][u]) son[p][u] = ++ idx;  //如果该字符下没有分支，则创建一个分支存入
        p = son[p][u];  //将最后得到的分支存进p
    }
    cnt[p] ++;  //标记p点为一个字符串的结尾
}

int query(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 n;
    cin >> n;
    
    while (n--)
    {
        char op[2];
        cin >> op >> str;
        if (*op == 'I') insert(str);
        else cout << query(str) << endl;
    }
    
    return 0;
}

AcWing题库-143-最大异或对

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

输入格式
第一行输入一个整数N。

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

输出格式
输出一个整数表示答案。

数据范围
1≤N≤10^5,
0≤Ai<2^31
输入样例：
3
1 2 3
输出样例：
3

代码

#include <iostream>

using namespace std;

const int N = 100010;

int n, idx;
int a[N], son[N * 31][2]；//son存储二进制数，只有0和1两种，只需两个空间

void insert(int x)
{
    int p = 0;
    for (int i = 30; i >= 0; i -- )
    {
        int &s = son[p][x >> i & 1];//s的地址指向x二进制数的第i位数字
        if (!s) s = ++ idx；//如果该位数字为0，将该位数字赋为1，即进行初始异或运算
        p = s;
    }
}

int search(int x)
{
    int p = 0, res = 0;
    for (int i = 30; i >= 0; i -- )//从最高位开始枚举x的每一位二进制数
    {
        int s = x >> i & 1;//s为x的二进制数的第i位数字
        if (son[p][!s])  //如果该位二进制数为0，则异或结果一定为0
        {
            res += 1 << i;//将i的值左移1位加入答案中
            p = son[p][!s];
        }
        else p = son[p][s];  //继续向下找
    }
    return res;
}

int main()
{
    cin >> n;
    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, search(a[i]));//查询结果取大

    cout << res;

    return 0;
}

AcWing题库-836-合并集合

题目
一共有 n 个数，编号是 1∼n，最开始每个数各自在一个集合中。

现在要进行 m 个操作，操作共有两种：

M a b，将编号为 a 和 b 的两个数所在的集合合并，如果两个数已经在同一个集合中，则忽略这个操作；
Q a b，询问编号为 a 和 b 的两个数是否在同一个集合中；
输入格式
第一行输入整数 n 和 m。

接下来 m 行，每行包含一个操作指令，指令为 M a b 或 Q a b 中的一种。

输出格式
对于每个询问指令 Q a b，都要输出一个结果，如果 a 和 b 在同一集合内，则输出 Yes，否则输出 No。

每个结果占一行。

数据范围
1≤n,m≤105
输入样例：
4 5
M 1 2
M 3 4
Q 1 2
Q 1 3
Q 3 4
输出样例：
Yes
No
Yes

题目解析：
用树存储每个集合，在查找每个点所在集合的根节点时，暴力方法是每次都从头开始向上查找，即x的父节点是p[x]，p[x]的父节点是p[p[x]]，直到p[x]=x才找到，这里可以采取路径压缩的优化方法，即每查找一个点，让其查找过程中经过的节点的父节点直接指向最后查找到的根节点（即p[x] = find(p[x])），这样后面再查找这条路径上点的根节点就可以直接找到，把时间压缩到接近O(1)

代码

#include <iostream>

using namespace std;

const int N = 100010;

int p[N];

int find(int x)  //查找点x所在集合的根节点
{
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

int main()
{
    int n, m;
    scanf ("%d%d", &n, &m);
    for (int i = 1; i <= n; i ++) p[i] = i;  //初始状态每个点各自在一个集合，均为集合的根节点
    
    while (m --)
    {
        char op[2];
        int a, b;
        scanf ("%s%d%d", op, &a, &b);
        if (*op == 'M') p[find(a)] = find(b);  //合并集合，直接连接两个集合的根节点，即p[x]=y
        else
        {  //查找两个点是否在一个集合，即查找两个点所在集合的根节点是否为同一个
            if (find(a) == find(b)) puts("Yes");
            else puts("No");
        }
    }
    return 0;
}

AcWing题库-837-连通块中点的数量

题目
给定一个包含 n 个点（编号为 1∼n）的无向图，初始时图中没有边。

现在要进行 m 个操作，操作共有三种：

C a b，在点 a 和点 b 之间连一条边，a 和 b 可能相等；
Q1 a b，询问点 a 和点 b 是否在同一个连通块中，a 和 b 可能相等；
Q2 a，询问点 a 所在连通块中点的数量；
输入格式
第一行输入整数 n 和 m。

接下来 m 行，每行包含一个操作指令，指令为 C a b，Q1 a b 或 Q2 a 中的一种。

输出格式
对于每个询问指令 Q1 a b，如果 a 和 b 在同一个连通块中，则输出 Yes，否则输出 No。

对于每个询问指令 Q2 a，输出一个整数表示点 a 所在连通块中点的数量

每个结果占一行。

数据范围
1≤n,m≤105
输入样例：
5 5
C 1 2
Q1 1 2
Q2 1
C 2 5
Q2 5
输出样例：
Yes
2
3

题目解析：
此题相对于原版并查集多了一个集合中点的维护，只需初始化每个集合点的个数为1，在合并集合时将两个集合中点的数量相加即可

代码：

#include <iostream>

using namespace std;

const int N = 100010;

int p[N], cnt[N];

int find(int x)  //查找点x所在集合的根节点
{
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

int main()
{
    int n, m;
    scanf ("%d%d", &n, &m);
    for (int i = 1; i <= n; i ++)
    {
        p[i] = i;
        cnt[i] = 1;  //初始状态每个集合点的个数为1
    }
    
    while (m --)
    {
        char op[2];
        int a, b;
        scanf ("%s", op);
        if (*op == 'C') 
        {
            scanf("%d%d", &a, &b);
            if(find(a) != find(b))
            {
                cnt[find(b)] += cnt[find(a)];
                p[find(a)] = find(b);  //当两个集合不相等时合并集合，将两个集合中点的数量相加  
            }
        }
        else if(op[1] == '1')
        {
            scanf("%d%d", &a, &b);
            if (find(a) == find(b)) puts("Yes");
            else puts("No");
        }
        else
        {
            scanf("%d", &a);
            cout << cnt[find(a)] << endl;
        }
    }
    return 0;
}

模板来源于AcWing算法基础课）