数据结构·下 QWQ

最新推荐文章于 2024-09-07 16:56:49 发布
最新推荐文章于 2024-09-07 16:56:49 发布
阅读量189 收藏
点赞数
分类专栏： 从入门到入土 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w2016218113/article/details/121626245
版权

数据结构

♥

KMP

♥

时间复杂度 O(n)

在已知字符串中 寻找 子串

♥
AcWing831. KMP字符串

//♥

#include <iostream>

using namespace std;

const int N = 1e5 + 5;
const int M = 1e6 + 5;

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

int main()
{
    scanf("%d%s%d%s", &n, p+1, &m, s+1); // 让字符串从 1 开始存
    
    //计算 next
    for(int i = 2, j = 0; i <= n; i ++ )
    {
        while(j && p[j + 1] != p[i]) j = ne[j];
        if(p[j + 1] == p[i]) j ++ ;
        ne[i] = j;
    }
    
    for(int i = 1, j = 0; i <= m; i ++ )
    {
        while(j && p[j + 1] != s[i]) j = ne[j];
        if(p[j + 1] == s[i]) j ++ ;
        
        if(j == n) 
        {
            printf("%d ", i - n);
            j = ne[j]; // 好像也可以不用写这句
        }
    }
    
    return 0;
}

♥

Trie

♥

典型应用：高效的 统计，排序和保存 大量 字符串集合（不仅限于字符串）

♥ AcWing835. Trie字符串统计

//♥

#include <iostream>

using namespace std;

const int N = 1e5 + 5;

int n, cnt = 0;
char op;
string s;
int son[N][26], ct[N]; // son 用于存 孩子结点的下标， ct 用于存数量

void Insert(string s)
{
    int p = 0;
    
    for(int i = 0; i < s.size(); i ++ )
    {
        int u = s[i] - 'a';
        if(!son[p][u]) son[p][u] = ++ cnt; // 有 孩子 结点后，再启用内存
                                           // son 数组用于指引 孩子结点的 “p” 为多少
        p = son[p][u];
    }
    
    ct[p] ++ ;
}

int Query(string s)
{
    int p = 0;
    
    for(int i = 0; i < s.size(); i ++ )
    {
        int u = s[i] - 'a';
        if(!son[p][u]) return 0;
        p = son[p][u];
    }
    
    return ct[p];
}

int main()
{
    cin >> n;
    
    while(n --)
    {
        cin >> op >> s;
        
        if(op == 'I') Insert(s);
        else cout << Query(s) << endl;
    }
    
    return 0;
}

♥ AcWing143. 最大异或对

//♥

#include <iostream>

using namespace std;

const int N = 1e5 + 5;
const int M = 31e5 + 5;

int n, cnt;
int son[M][2], a[N];

void Insert(int x)
{
    /*
        Q: 为什么 i 一定要从 30 到 0 ，不能反过来？
        
        A: 流程是 寻找这一位是否存在 “反数”，
           若存在则确定该位的值，继续寻找下一位
           
           若从 0 到 30，则是优先保证低位存在“反数”，可凑 1
           不一定能保证高位
           
           而从 30 到 0，是优先保证高位为 1
           先要保证高位尽可能大，才能找到最大值
           
           例如：
                要找 6（110）与  7（111）和 0（000），哪一队组合异或值更大
            若先确保低位，0 要找 1，会选中 7 (111) 分支，最后结果为 1
            若先确保高位，1 要找 0，会选中 0 (000) 分支，最后结果为 6(110)
    */
    int p = 0;
    for(int i = 30; i >= 0; i -- ) // i 表示右移的位数
    {
        int u = x >> i & 1; // 取 右移后 二进制最低位上的数字
        if(!son[p][u]) son[p][u] =  ++ cnt;
        p = son[p][u];
    }
}

int Query(int x)
{
    int res = 0, p = 0;
    
    for(int i = 30; i >= 0; i -- )
    {
        int u = x >> i & 1;
        if(son[p][!u])
        {
            res += 1 << i;
            p = son[p][!u];
        }
        else p = son[p][u];
    }
    
    return res;
}

int main()
{
    cin >> n;
    
    for(int i = 0; i < n; i ++ ) 
    {
        cin >> a[i];
        Insert(a[i]);
    }
    
    int ans = 0;
    for(int i = 0; i < n; i ++ ) ans = max(ans, Query(a[i]));
    
    cout << ans << endl;
    
    return 0;
}

♥

并查集

♥

  1. 将两个集合 合并
  2. 查询两个元素是否在一个集合中
//♥

#include <iostream>

using namespace std;

int const N = 1e5 + 5;

int n, m;
int p[N], r[N];

int Find(int x)
{
    if(p[x] != x)
    {
    	int px = Find(p[x]);
    	r[p[x]] = r[px]; // 根据题目需要 变通该式
    	p[x] = px;
    }
	return p[x]
}

int main()
{
    cin >> n >> m;
    for(int i = 1; i <= n; i ++ ) p[i] = i;
    
    while(m --)
    {
        char op;
        int x, y;
        cin >> op >> x >> y;
        
        int px = Find(x), py = Find(y);
        if(op == 'M') 
        {
            if(px != py) p[px] = py;
        }
        else 
        {
            if(px == py) puts("Yes");
            else puts("No");
        }
    }
    
    return 0;
}

♥ 典中典拓展域并查集

POJ.1182 食物链

// ♥

#include <iostream>

using namespace std;

const int N = 50010;

int n, k, ans = 0;
int p[3*N]; // [1, n]同类 [n+1, 2n]食物 [2n+1, 3n]天敌

int Find(int x)
{
    if(p[x] != x) p[x] = Find(p[x]);
    
    return p[x];
}

void Unite(int x, int y)
{
    int px = Find(x), py = Find(y);
    
    if(px != py) p[px] = py;
}

int main()
{
    cin >> n >> k;
    for(int i = 1; i <= 3*n; i ++ ) p[i] = i;
    
    while(k --)
    {
        int op, x, y;
        scanf("%d%d%d",&op,&x,&y);
        
        if(x > n || y > n)
        {
            ans ++ ;
            continue;
        }
        
        if(op == 1)
        {
            if(Find(x) == Find(y + n) || Find(x) == Find(y + 2*n)) ans ++ ;
            else
            {
                Unite(x, y);
                Unite(x + n, y + n);
                Unite(x + 2*n, y + 2*n);
            }
        }
        else
        {
            if(Find(x) == Find(y) || Find(x) == Find(y + n)) ans ++ ;
            else
            {
                Unite(x, y + 2*n);
                Unite(x + n, y);
                Unite(x + 2*n, y + n);
            }
        }
    }
    
    cout << ans << endl;
    
    return 0;
}

♥ codeforces.D - Mahmoud and a Dictionary

// ♥

#include <iostream>
#include <unordered_map>

using namespace std;

const int N = 1e5 + 5;

int q, n, m, idx = 0;
int p[2*N]; // [1, n]同义 [n+1, 2*n]反义
unordered_map<string, int> mp;

int Find(int x)
{
    if(p[x] != x) p[x] = Find(p[x]);
    
    return p[x];
}

void Unite(int x, int y)
{
    int px = Find(x), py = Find(y);
    
    if(px != py) p[px] = py;
}

int main()
{
    cin >> n >> m >> q;
    for(int i = 1; i <= 2*n; i ++ ) p[i] = i;
    
    for(int i = 1; i <= n; i ++ )
    {
        string s;
        cin >> s;
        mp[s] = ++ idx;
    }
    
    string a, b;
    
    while(m --)
    {
        int op;
        scanf("%d", &op);
        cin >> a >> b;
        
        int x = mp[a], y = mp[b];
        if(op == 1)
        {
            if(Find(x) != Find(y + n))
            {
                Unite(x, y);
                Unite(x + n, y + n);
                printf("YES\n");
            }
            else printf("NO\n");
        }
        else
        {
            if(Find(x) != Find(y))
            {
                Unite(x, y + n);
                Unite(x + n, y);
                printf("YES\n");
            }
            else printf("NO\n");
        }
        
    }
    
    while(q --)
    {
        cin >> a >> b;
        
        int x = mp[a], y = mp[b];
        
        if(Find(x) == Find(y)) printf("1\n");
        else if(Find(x) == Find(y + n)) printf("2\n");
        else printf("3\n");
    }
    
    return 0;
}

♥

顺便试了试 输出 哪个快 （好像不明显）
在这里插入图片描述
♥

堆 (Heap)

♥

//♥

#include <iostream>

using namespace std;

const int N = 1e5 + 5;

int n, m;
int h[N], cnt = 0;

void down(int i)
{
    int t = i;
    if(i*2 <= cnt && h[i<<1] < h[t]) t = i << 1;
    if(i*2 + 1 <= cnt && h[i<<1|1] < h[t]) t = i << 1 | 1;
    
    if(t != i)
    {
        swap(h[i], h[t]);
        down(t); // ☆向下更新
    }
}

int main()
{
    cin >> n >> m;
    for(int i = 1; i <= n; i ++ ) cin >> h[++cnt];
    
    for(int i = n / 2; i > 0; i --) down(i);
    
    while(m --)
    {
        cout << h[1] << ' ';
        swap(h[1], h[cnt]);
        cnt -- ;
        down(1);
    }
    
    return 0;
}

♥ AcWing839. 模拟堆

//♥

#include <iostream>

using namespace std;

const int N = 1e5 + 5;

int n;
int h[N], idx = 0; // idx 有 序号、下标 的意思
int k[N], pk[N], cnt = 0; // k 存储第 k 个数下标，ph 存储 h[i] 的cnt，即 k 数组下标
                          // 即 k[i] = j; pk[j] = i;

void heap_swap(int i, int j)
{
    swap(h[i], h[j]);
    swap(k[pk[i]], k[pk[j]]); // 先通过 pk 寻找对应的 k 的下标，交换 k
    swap(pk[i], pk[j]);       // 再交换 pk 指引对应 k 的下标
}

void up(int i)
{
    if((i>>1) > 0 && h[i] < h[i>>1]) // 判断 上方是否存在结点 ，0 默认为空的结点
    {
        heap_swap(i, i>>1);
        up(i>>1); // 继续向上递归
    }
}

void down(int i)
{
    int t = i;
    
    if((i << 1) <= idx && h[t] > h[i<<1]) t = i << 1;
    if((i << 1|1) <= idx && h[t] > h[i<<1|1]) t = i << 1|1;
    
    if(t != i)
    {
        heap_swap(i, t);
        down(t);
    }
}

int main()
{
    cin >> n;
    
    while(n --)
    {
        string op;
        cin >> op;
 
        if(op == "I")
        {
            cin >> h[ ++ idx];
            k[ ++ cnt] = idx; // 记录 第 cnt 个输入的数 对应 h 数组中的下标
            pk[idx] = cnt; // 记录 h[idx] 对应 k 数组中的下标
            up(idx);
        }
        else if(op == "PM") cout << h[1] << endl;
        else if(op == "DM")
        {
            heap_swap(1, idx);
            -- idx;
            down(1);
        }
        else if(op == "D")
        {
            int kk;
            cin >> kk;
            
            kk = k[kk]; // 查询 第 kk 个数 在 h 数组中的下标
            heap_swap(kk, idx);
            -- idx;
            up(kk);
            down(kk);
        }
        else
        {
            int kk, x;
            cin >> kk >> x;
            
            kk = k[kk];
            h[kk] = x;
            up(kk);
            down(kk);
        }
        
    }
    
    return 0;
}

♥

哈希表

♥

当数据范围很大，而数据数量较小时使用
例如 -109 ≤ ai ≤ 109, 1 ≤ N ≤ 105;

♥ 关于 0x3f3f3f3f 到底有多大（第一个是数字 0）
3f3f3f3f > 109
在这里插入图片描述
♥ 两个相加不会超过 int
在这里插入图片描述
在这里插入图片描述

♥
开放寻址法

//♥

#include <iostream>
#include <cstring>

using namespace std;

#define INF 0x3f3f3f3f

const int N = 2e5 + 3; // 尽量开 2 ~ 3 倍 减少冲突事件，利用空间节省时间
					   //  + 3 ，质数 也是为了减少冲突事件

int n;
int h[N];

int Find(int x)
{
    int t = (x % N + N) % N; // (x % N + N) 防止出现负数
    while(h[t] != INF && h[t] != x)
    {
        t ++ ;
        if(t == N) t = 0;
    }
    
    return t;
}

int main()
{
    memset(h, 0x3f, sizeof(h)); // 0x3f3f3f3f > 1e9, 是范围外的数
    							// 可以当做 判断 h[i] 是否为空的标记
    cin >> n;
    while(n --)
    {
        char op;
        int x;
        cin >> op >> x;
        
        if(op == 'I') h[Find(x)] = x;
        else
        {
            if(h[Find(x)] != INF) puts("Yes");
            else puts("No");
        }
    }
    
    return 0;
}

♥
拉链法

// ♥

#include <iostream>
#include <cstring>

using namespace std;

const int N = 1e5 + 3;

int n, idx = 0;
int e[N], ne[N], h[N]; // e 存储元素，ne 存储 上一个取模结果相等元素 的下标，
                       // h[i] 存储最新 取模结果为 i 的元素 在 e 中的下标

void Insert(int x)
{
    int t = (x % N + N) % N; // (x % N + N) 防止出现负数
    e[idx] = x;
    ne[idx] = h[t];
    h[t] = idx ++ ;
}

int Find(int x)
{
    int t = (x % N + N) % N;
    for(int i = h[t]; i != -1; i = ne[i])
    {
        if(e[i] == x) return 1;
    }
    
    return 0;
}

int main()
{
    cin >> n;
    
    memset(h, -1, sizeof(h));
    while(n --)
    {
        string op;
        int x;
        cin >> op >> x;
        
        if(op == "I") Insert(x);
        else 
        {
            if(Find(x)) puts("Yes");
            else puts("No");
        }
    }
    
    return 0;
}

♥ 字符串哈希

看做一个 P 进制的 数值
P 一般取 131 或 13331

在这里插入图片描述

♥ AcWing.841. 字符串哈希

//♥

#include <iostream>

using namespace std;

typedef unsigned long long ULL; // 用 unsigned 可不用取模
                                // 如数据溢出，等价于对 2^64 取模
const int N = 1e5 + 5;
const int P = 131; // 通常取 131 或 13331

int n, m;
char str[N];
ULL h[N], p[N]; // p[i] 表示 p^i 的值

ULL Find(int l, int r)
{
    return h[r] - h[l - 1] * p[r - l + 1];
}

int main()
{
    cin >> n >> m >>  str + 1; // +1 从下标 1 开始存储
    
    p[0] = 1; // 不初始化 p 数组中的值会一直为 0 
    for(int i = 1; i <= n; i ++ )
    {
        p[i] = p[i - 1] * P;
        h[i] = h[i - 1] * P + str[i];
    }
    
    while(m --)
    {
        int l1, l2, r1, r2;
        cin >> l1 >> r1 >> l2 >> r2;
        
        if(Find(l1, r1) == Find(l2, r2)) puts("Yes");
        else puts("No");
        
    }
    
    return 0;
}

♥

抹消存在
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——跳表（skip list）
qq_42006733的博客
02-27 1229
跳表 跳表是一种各方面性能都比较优秀的动态数据结构，可以支持快速的插入、删除、查找操作。 跳表的实质就是一种可以进行“二分查找”的有序链表，跳表在原有的有序链表上面增加了多级索引，通过索引来实现快速查找。 理解跳表 对于一个单链表来讲，即便链表中存储的数据是有序的，如果我们要想在其中查找某个数据，也只能从头到尾遍历链表。 这样查找效率就会很低，时间复杂度会很高，时间复杂度是 O(n...
整理一下叭qwq
weixin_52796601的博客
05-11 1628
第一课 关于double定义的数，scanf（）只能%lf，printf（）可以%lf. 数据类型是啥，往后就怎么用，不要胡搞。 scanf（）的输入按照引号里面原样输入。 括号也算是一个字符，在字符的输入的时候要注意这个。 反斜杠从左斜向下\。 printf("k=%d,k=%o,k=%x\n",k,k,k); 分别是十进制，八进制，十六进制 注意字节长度 short int a; int b = 65536; a = b; printf("%d\n", a) 语句：printf("%
数据结构下
qq_45662065的博客
10-30 75
数据结构与算法（增加） 队列 定义：、队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 特点：FIFO（先进先出），front头，rear尾（初始值都等于-1，但front是在第一个数据的前一个位置，rear在正末尾数据位置） 数组实现栈声明如下 MAXSIZE = 10 queue = [0]*MAXSIZE front = rear = -1 具体范例 MAXSI...
数据结构(下)
liupinyang的博客
01-16 226
数据结构(下) 1.1Map映射操作 object Mapde { // 请将list(3,5,7) 中的所有元素都* 2 def main(args: Array[String]): Unit = { val list = List(1,2,3,5,4) val lis2: mutable.MutableList[Int] = mutable...
数据结构下1
qq_44144025的博客
07-15 115
数据结构 = 结构定义 + 结构操作 数据结构的唯一目的是处理数据，增删改查操作后仍维护结构的性质。 一、二叉平衡树 用途：解决与排名相关的检索需求 查找操作的时间复杂度O(logN) ~ O（N） 不稳定 二叉查找树 哈希表 查找时间复杂度 O(logN) ~ O(N） O(1) 数据顺序 有序 无序 空间复杂度 O(N) 设计复杂 缺点 不稳定 rehash扩容耗时 ...
数据结构下篇
weixin_30266829的博客
08-14 90
4-3集合 集合(set)是在ES6中引入的一种数据结构，用于表示唯一值的集合，所以它不能包含重复值。接 下来这一小节，就让我们具体来看一下这种新的数据结构。 4-3-1什么是集合 在ES6标准制定以前，可选的数据结构类型有限，可以说只有数组这种数据结构。而数组使用的 又是数值型索引，因而经常被用于来模拟队列和栈的行为。但是如果需要使用非数值型索引，就 会用非数组对象创建所需的...
王道考研数据结构笔记
热门推荐
weixin_45016439的博客
04-15 2万+
2022年4月16日 整理了这篇博客的pdf版本，但是缺的部分可能没法补上啦，把毕业的事忙完了可能！可以！对着书把笔记再整理一遍！所以所以，如果有需要pdf版本的可以私信我(有偿，奶茶钱这样)。 大家加油！一定会成功的！ 王道考研数据结构笔记 第二章 线性表 2.1 线性表的定义和基本操作 要点： 线性表的基本操作——创销、增删、改查 传入参数时，何时要用引用 & 2.2 线性表的顺序表示 2.2.1 顺序表的定义 顺序表的实现———静态分配 #include <stdio.h>
数据结构课程设计word文档.doc
04-26
单向循环链表是一种链式数据结构，每个节点包含数据和指向下一个节点的指针，最后一个节点的指针会回指到链表的第一个节点，形成一个闭环。这种结构允许我们方便地遍历和修改链表，特别是在需要处理循环逻辑的问题时...
数据结构之ST表 详解
weixin_55786578的博客
05-01 1907
ST表是基于倍增思想通过动态规划实现的一种处理区间最值问题的算法 （RMQ）。倍增思想既可以直接用于设计解决某些问题的特定算法，也可以与其它 的算法结合优化时间复杂度。我们先来回顾一下倍增的处理思想。
「数据结构」Link-Cut Tree(LCT)
qq_45562973的博客
01-28 1173
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 #1.0 简述 #1.1 动态树问题 维护一个森林，支持删除某条边，加入某条边，并保证加边、删边之后仍然是森林。我们需要维护这个森林的一些信息。 一般的操作有两点连通性，两点路径权值和等等。 #1.2 实链剖分 先来回顾一下树链剖分，我们可以按照子树大小进行剖分（重链剖分），也
qwq.zip
11-11
例如，如果"qwq.zip"包含的是一个HTML文件，我们可以讨论网页开发、HTML语言的基本结构、前端技术等；如果是图片，我们则可以探讨图像格式、压缩算法、数字图像处理等内容。如果您能提供这些详细信息，我将很乐意...
算法练习题13——除自身以外数组的乘积（动态规划）
hello77的blogggg 祝你得偿所愿
09-04 863
给你一个整数数组nums，返回 数组answer，其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。
【大数据分析与挖掘算法】matlab实现——Apriori关联规则算法
Robbi_的博客
09-04 615
四、实验结果。
树状数组记录
volcan的博客
09-06 597
树状数组（Fenwick Tree）是一种用于维护数组前缀和的数据结构，支持高效的单点更新和区间查询操作。它的查询和更新时间复杂度为Ologn，适用于需要频繁更新和查询的场景。
力扣刷题--1534. 统计好三元组【简单】
m0_75266675的博客
09-04 343
力扣刷题--1534. 统计好三元组【简单】
【算法】单词出现次数和位置统计
Hanbuhuic的博客
09-04 368
编写一个程序，用于统计一个给定单词在一段文本中出现的次数以及第一次出现的位置。如果单词在文本中出现，则输出出现次数和第一次出现的位置（位置从0开始计算）。如果单词没有出现，则输出-1。
专题一_双指针_算法专题详细总结
2301_80636070的博客
09-06 852
利用双指针，cur=0，dest=-1，只要nums[cur]==0 dest就走两格；否则 dest走一格；但是无论怎么样cur都走一格。直到dest到达结尾处n-1 停止，即 判断dest>=n-1 处 break；
[ C++ ] 一文复习（基础语法，语言特性，STL回顾）
2301_79175236的博客
09-04 1036
C++复习参考文，待完善
洛谷刷题之B2089 数组逆序重存放
最新发布
resco的博客
09-07 942
洛谷刷题之B2089 数组逆序重存放
约瑟夫环问题的数据结构课程设计文档
本次数据结构课程设计的题目是约瑟夫环问题。在这个问题中，有n个人按照顺时针方向围坐一圈，每个人只有一个密码。开始时，我们任选一个正整数m作为报数上限值。从第一个人开始顺时针方向自1开始顺序报数，当报到m时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值