Acwing - 算法基础课 - 笔记(数据结构 · 三)

文章目录

    • 数据结构(三)
      • 哈希表
        • 哈希表的存储
        • 字符串哈希
      • STL
        • vector
        • pair
        • string
        • queue
        • priority_queue
        • stack
        • deque
        • set
        • map
        • bitset

数据结构(三)

本节讲解的是哈希表,和C++的STL容器的基本使用

哈希表

哈希表的作用:把一个比较大的空间,映射到一个比较小的空间。

一般做哈希运算时,取一个质数作为模,会使得冲突的概率降低

哈希表的存储

冲突解决方法

  • 开放寻址法
  • 拉链法

练习题:Acwing - 840 模拟散列表

拉链法

#include
#include
using namespace std;

const int N = 1e5 + 3;

int h[N]; // 存储的都是节点的下标
int e[N], ne[N], idx; // 存储节点值和next指针

int mod(int x) {
	return (x % N + N) % N;
}

void insert(int x) {
	int k = mod(x);
	e[idx] = x; // 新分配一个节点
	ne[idx] = h[k]; // 这个节点的next指向链表头
	h[k] = idx; // 新的链表头
	idx++;
}

bool query(int x) {
	int k = mod(x);
	for(int i = h[k]; i != -1; i = ne[i]) {
		if(e[i] == x) return true;
	}
	return false;
}


int main() {
    int n;
	scanf("%d", &n);
	memset(h, -1, sizeof h); // -1表示空节点
	char op;
	int x;
	while(n--) {
		cin >> op >> x;
		if(op == 'I') {
			insert(x);
		} else if(op == 'Q') {
			if(query(x)) printf("Yes\n");
			else printf("No\n");
		}
	}
	return 0;
}

开放寻址法

#include 
#include 

using namespace std;

const int N = 200003, null = 0x3f3f3f3f;

int h[N];

int find(int x)
{
    int t = (x % N + N) % N;
    while (h[t] != null && h[t] != x)
    {
        t ++ ;
        if (t == N) t = 0;
    }
    return t;
}

int main()
{
    memset(h, 0x3f, sizeof h);

    int n;
    scanf("%d", &n);

    while (n -- )
    {
        char op[2];
        int x;
        scanf("%s%d", op, &x);
        if (*op == 'I') h[find(x)] = x;
        else
        {
            if (h[find(x)] == null) puts("No");
            else puts("Yes");
        }
    }

    return 0;
}

注意,memset函数,是按字节来设置值的,上面定义了null0x3f3f3f3f,这调用memset时,只需要设置为0x3f即可。

特殊的,如果要初始化为0或者-1,则直接设置为0或-1就可以了,因为0的二进制表示是全零(00000000),-1是全1(11111111)。设置1个字节和4个字节是一样的。

字符串哈希

字符串前缀哈希法:对于字符串每个位置作为前缀,求一下其哈希值

如,有字符串 s = ABCDE

则求解的哈希数组

h[1] = A 的哈希值

h[2] = AB 的哈希值

h[3] = ABC 的哈希值

如何求解一个字符串的哈希值?

将字符串看成一个P进制的数,比如字符串ABCD,我们把A映射为1,B映射为2,C映射为3,D映射为4。则ABCD可以看成一个P进制的数字1234。则ABCD这个字符串的哈希值为

(1 × P3 + 2 × P2 + 3 × P1 + 4 × P0 ) mod Q

通常不要把一个字母映射为0,这样会导致重复。比如把A映射为0,则A是0,AA也是0,AAA还是0。

在做字符串哈希时,我们不考虑冲突的情况。

我们可以取 P = 131或13331,Q = 264 ,这样在99.99%的情况下是不会出现冲突的(据yxc所说)

可以将h数组的类型取成unsigned long long (64位),这样就无需对264 取模,溢出就直接相当于取模

求解字符串前缀哈希值有什么用?

可以求解任意的子串的哈希值! 这是使用KMP算法都不好做到的。

可以用于快速判断两个字符串是否相等。(用模式匹配需要至少O(n),而字符串哈希只需要O(1))

比如我们要求解字符串S中[L,R]这段子串的哈希值

我们可以先得到h[L-1]的值,以及h[R]的值

先将h[L-1]左移R-L+1位(P进制),让其与h[R]对齐,然后二者相减,便得到了[L,R]区间的子串表示的P进制的数

即 h[R] - h[L-1] × PR-L+1

并且,在计算字符串S的前缀哈希值时,容易得到如下的递推式

h[i] = h[i - 1] × P + S[i]

练习题:acwing - 841 : 字符串哈希

#include
using namespace std;

const int P = 131, N = 1e5 + 10;

typedef unsigned long long ULL;

// h[N] 用来存字符串前缀哈希, p[N] 用来存p的幂
ULL h[N], p[N];
int n, m;
char str[N];

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

int main() {
	scanf("%d%d%s", &n, &m, str + 1);

	p[0] = 1; // p[] 存 p 的幂
	for(int i = 1; i <= n; i++) {
		// 初始化h数组
		p[i] = p[i - 1] * P;
		h[i] = h[i - 1] * P + str[i];
	}
	while(m--) {
		int l1, r1, l2, r2;
		scanf("%d%d%d%d", &l1, &r1, &l2, &r2);
		if(get(l1, r1) == get(l2, r2)) printf("Yes\n");
		else printf("No\n");
	}
	return 0;
}

------2023/09/03 更新
重做的时候发现,实际上,只要知道字符串每个位置上的值域空间,也可以只在值域空间内进行映射就可以了,比如只包含大小写字母和数字的字符串,它每个位置上的字符,取值只有62种,其中小写英文字母一共26个,大写英文字母共26个,数字0-9共10个,也就是其值域空间的大小只有62,所以我们可以把每个字符映射为0-61这个区间范围内的数字,那么就可以将字符串表示为一个62进制的数。而由于我们通常不把一个字符映射为0(如前所述),所以实际上我们将每个字符映射到1-62这个范围,那么就应该是63进制的一个数。下面的代码提交也是可以AC的

#include 
typedef long long LL;
using namespace std;
const int N = 1e5 + 10, P = 63;
int n, m, l1, l2, r1, r2;
char cs[N];
LL h[N], p[N];

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

int char2int(char c) {
	if (c >= 'a' && c <= 'z') return c - 'a' + 1;
	if (c >= 'A' && c <= 'Z') return c - 'A' + 1 + 26;
	return c - '0' + 1 + 26 + 26;
}

int main() {
	ios::sync_with_stdio(false);
	cin >> n >> m;
	cin >> cs + 1;
	p[0] = 1;
	for (int i = 1; i <= n; i++) {
		h[i] = h[i - 1] * P + char2int(cs[i]);
		p[i] = p[i - 1] * P;
	}
	while (m--) {
		cin >> l1 >> r1 >> l2 >> r2;
		if (get(l1, r1) == get(l2, r2)) printf("Yes\n");
		else printf("No\n");
	}
	return 0;
}

其他练手题目:在acwing上搜关键字 “哈希”

STL

C++的STL库中提供了很多的数据结构,包括一些很复杂的数据结构。

本小节讲解了C++的STL库中常用的一些数据结构,主要包括了

  • vector

    变长数组,基本思想是倍增(类似于java中的ArrayList)

  • pair

    存储一个二元组,二元组的变量类型可以任意

  • string

    字符串,常用的函数substr()c_str()

  • queue

    队列,push()front()back()pop()

  • priority_queue

    优先队列,本质是个堆。push()top()pop()

  • stack

    栈。push()top()pop()

  • deque

    双端队列。可以在队头队尾进行插入删除,并且支持随机访问

  • set,map,multiset,multimap

    基于平衡二叉树(红黑树),动态维护有序序列。这些set/map支持跟排序相关的操作,如lower_bound/upper_bound方法,也支持迭代器的++--,但是其增删改查的时间复杂度是O(logn)。

  • unordered_set,unordered_map,unordered_multiset,unordered_multimap

    基于哈希表。这些set和map和上面的set/map类似。但是这些unordered的set/map的增删改查的时间复杂度是O(1),效率比上面的更快,但不支持lower_bound()和upper_bound(),也不支持迭代器的++--

    如使用unordered_map,则需要头文件#include

  • bitset

    压位

vector
#include
#include
using namespace std;

int main() {
    vector<int> a; // 最简单的初始化方式
    vector<int> a(10); // 定义一个长度为10的vector
    vector<int> a(10, 3); //定义一个长度为10的vector,并将每个元素初始化为3
    vector<int> a[10]; // 定义一个vector数组,数组大小为10
    
    // vector支持的函数
    a.size(); // vector中的元素个数
    a.empty(); // vector是否为空
    // 上面2个方法的时间复杂度是O(1), 并且其他的容器都有这2个方法
    a.clear(); // 清空
    a.front(); // 返回第一个
    a.back();
    a.push_back();
    a.pop_back();
    a.begin(); // 是第一个元素的位置
    a.end(); // 是最后一个元素的下一个位置
    // vector支持用[]进行随机寻址, 这一点与数组相同
    a[0]; // 取vector中第一个元素
    // vector支持比较运算
    vector<int> a(4, 3), b(3, 4);
    // a = [3,3,3,3]   b = [4,4,4]
    if(a < b) printf("a < b\n"); // 比较大小时是按照字典序
    
    // vector的遍历
    vector<int> a;
    for(int i = 0; i < 10; i++) a.push_back(i);
    for(int i = 0; i <a.size(); i++) cout << a[i] << " ";
    cout << endl;
    
    for(vector<int>::iterator it = a.begin(); i != a.end(); i++) cout << *i << " ";
    cout << endl;
    
    // C++ 11 的新特性, for each 遍历
    for(auto x : a) cout << x << " ";
    cout << endl;
    return 0;
}

注意:操作系统为某一个程序分配内存空间所需要的时间,与要分配的空间大小无关。只与分配次数有关。比如请求分配一个大小为1的空间,和请求分配一个大小为100的空间,所需时间是一样的。

比如,一次申请大小为1000的数组,与申请1000次大小为1的数组,它们各自所需的时间,就是1000倍的关系。

所以,变长数组,要尽量减少申请空间的次数。

所以vector的倍增,大概就是,每次数组长度不够时,就把大小扩大一倍(新申请一个大小为原先2倍的数组),并把旧数组的元素copy过来

若一个vector最终元素个数为n,则其分配空间的次数为logn。拷贝元素的次数约为n。平均到每个元素上的时间复杂度就是O(1)

pair

pair定义在utility库中,通常直接引入iostream就能够使用

#include
using namespace std;

int main() {
    pair<int,string> p;
    p.first; //第一个元素
    p.second; //第二个元素
    //pair也支持比较运算,以first为第一关键字,second为第二关键字
    // 构造一个pair
    p = make_pair(10, "hby");
    p = {10, "hby"}; // C++ 11 可以直接这样初始化
    // 当某一个事物有2个属性时,并且需要按照某一个属性进行排序时,
    // 可以将需要排序的属性放到fisrt, 另一个属性放到second
    
    // 当然也可以用pair来存3个属性, 如下
    pair<int, pair<int, int>> p;
}
string
#include
#include
using namespace std;

int main() {
    string a = "hby";
    a += "haha"; // 字符串拼接
    a += 'c';
    
    a.size();
    a.length(); // 两种取长度都可以
    
    a.empty();
    a.append("3");
    a.append(10, '3'); // 追加10个3
    
    a.find('b'); // 返回该字符的下标, 从左往右找到的第一个该字符
    
    a.front(); // 字符串第一个字符
    a.back(); // 字符串最后一个字符
    a.substr(1, 3); // 第一个参数是下标起始位置, 第二个参数是长度
    // 上面就是从下标为1的位置开始, 取后面长度为3的子串, 结果就是byh
    // 当第二个参数的长度, 超过了字符串的长度时, 会输出到字符串结尾为止
    a.substr(1); // 也可以省略第二个参数, 则返回下标1之后的子串
    
    a.c_str(); //返回字符串a存储字符串的起始地址
    printf("%s\n", a.c_str());
}
queue
#include
#include
using namespace std;

int main() {
    queue<int> q;
    q.push(1); // 向队尾插入
    q.pop(); // 弹出队头元素, 注意返回的是void
    q.front(); // 返回队头 
    q.back(); // 返回队尾
    q.size();
    q.empty();
    // queue 没有clear函数
    // 想清空一个queue怎么办? 
    q = queue<int>(); // 直接重新构造一个queue
}
priority_queue

优先队列,底层是个堆

#include
#include
#include
using namespace std;

int main() {
    // 默认是大根堆
    priority_queue<int> q;
    // 想定义一个小根堆 怎么办?
    // 1. 想插入x时, 直接插入-x
    // 2. 定义时, 直接定义成小根堆, 如下(需要借助vector)
    priority_queue<int, vector<int>, greater<int>> heap;
    
    q.push();
    q.top(); // 返回堆顶元素
    q.pop(); // 弹出堆顶元素
}
stack
#include
#include
using namespace std;

int main() {
    stack<int> s;
    s.push(); // 压栈
    s.top(); // 返回栈顶
    s.pop(); // 弹出栈顶
}
deque

双端队列,或者叫加强版的vector。支持很多种方法,但是速度会比较慢,所以一般不怎么用

#include
#include
using namespace std;

int main() {
    deque<int> q;
    q.clear(); // 有clear
    
    q.front();
    q.back();
    
    q.push_back();
    q.pop_back();
    
    q.push_front();
    q.pop_front();
    // 并且支持随机寻址
    q[0];
    // 支持begin()和end()迭代器
}

set
#include
#include
using namespace std;

int main() {
    set<int> s; // 不能有重复元素, 插入一个重复元素, 则这个操作会被忽略
    multiset<int> ms; // 可以有重复元素
    // set 和 multiset 支持的操作
    
    insert(1); // 时间复杂度 O(logn)
    find(1); // 查找一个数, 若不存在, 则返回end迭代器
    count(1); // 返回某个数的个数, set只会返回0或1, multiset则可能返回大于1
    erase(1); // 删除所有1的元素  时间复杂度 O(k + logn), 其中k为元素个数
    erase(??); // 输入一个迭代器, 则只会删迭代器
    // set 比较核心的操作
    lower_bound(x); //返回大于等于x的最小的数的迭代器(注意, 返回的是迭代器)
    upper_bound(x); // 返回大于x的最小的数的迭代器 (注意, 返回的是迭代器)
    // begin() , end() 迭代器
}
map
#include
#include
using namespace std;

int main() {
    insert(); // 插入的是一个pair
    erase(); // 输入的参数是一个pair或者迭代器
    find();
    lower_bound();
    upper_bound();
    // 可以像使用数组一样使用map
    // map的几乎所有操作的时间复杂度是 O(logn), 除了size(), empty() 
    
    map<string,int> m;
    m["hby"] = 1; // 插入可以直接这样操作
    
    cout << m["hby"] << endl; // 查找
}
bitset

比如想要开一个1024长度的bool数组,由于C++的bool类型是1个字节。

则需要1024个字节,即1KB。但实际我们可以用位来表示bool,则只需要1024个位,即128字节

bitset支持所有的位运算,以及移位

#include
using namespace std;

int main() {
    bitset<1000> s;
    // 支持 ~, &, |, ^
    // 支持 >>, <<
    // 支持 ==, !=
    // 支持 []
    // count() 返回有多少个1
    // any() 是否至少有一个1
    // none() 是否全为0
    // set() 把所有位置置为1
    // set(k, v)  将第k位变成v
    // reset() 把所有位置变成0
    // flip() 把所有位置取反, 等价于 ~
    // flip(k) 把第k位取反
}

忘了某个STL容器的用法,可以到下面的官方地址查找

资料地址:www.cplusplus.com/reference/

你可能感兴趣的:(算法,Acwing算法基础课,算法,字符串哈希,哈希)