本周总结（7.13-7.19）（数据结构）

本周主要复习单链表，双链表，栈，队列，单调栈，单调队列，KMP，Trie，并查集，堆，哈希表，树状数组和线段树等内容。

算法总结

单链表

int idx, ne[N], e[N], h;

void add_h(int x) //头结点插入
{
    e[idx] = x;
    ne[idx] = h;
    h = idx ++ ;
}

void insert(int k, int x) //第k个后插入
{
    e[idx] = x;
    ne[idx] = ne[k];
    ne[k] = idx ++ ;
}

void re(int k) //删除第k个
{
    ne[k] = ne[ne[k]];
}

单调栈

常见模型：找出每个数左边离它最近的比它大/小的数

int tt = 0, stk[N];
for (int i = 1; i <= n; i ++ )
{
    while (tt && check(stk[tt], i)) tt -- ;
    stk[ ++ tt] = i;
}

单调队列

常见模型：找出滑动窗口中的最大值/最小值

int hh = 0, tt = -1, q[N];
for (int i = 0; i < n; i ++ )
{
    while (hh <= tt && check_out(q[hh])) hh ++ ;  // 判断队头是否滑出窗口
    while (hh <= tt && check(q[tt], i)) tt -- ;
    q[ ++ tt] = i;
}

KMP

求next数组
ne[i]表示以i结尾的字符串，前缀和后缀长度为ne[i]的子串相等，且该子串的长度最大

void cal_next(char a[]) //a从下标1开始记录
{
    for (int i = 0, j = 2; j <= n; j ++ ) //j指针从2开始，因为ne[1] = 0
    {
        while (i && a[i + 1] != a[j]) i = ne[i];
        if (a[i + 1] == a[j]) i ++ ;
        ne[j] = i;
    }
}

Trie

int tr[N][M]; N为字符串的总长度，M为可能出现的字符种数

void insert(char *str) // 插入一个字符串
{
    int p = 0;
    for (int i = 0; str[i]; i ++ )
    {
        int u = str[i] - 'a';
        if (!tr[p][u]) tr[p][u] = ++ idx;
        p = tr[p][u];
    }
    cnt[p] ++ ; //记录结束位置
}

int query(char *str) // 查询字符串出现的次数
{
    int p = 0;
    for (int i = 0; str[i]; i ++ )
    {
        int u = str[i] - 'a';
        if (!tr[p][u]) return 0;
        p = tr[p][u];
    }
    return cnt[p];
}

并查集

朴素并查集

int p[N]; //存储每个点的祖宗节点

int find(int x) // 返回x的祖宗节点
{
	if (p[x] != x) p[x] = find(p[x]);
	return p[x];
}

for (int i = 1; i <= n; i ++ ) p[i] = i; // 初始化，假定节点编号是1~n

p[find(a)] = find(b); // 合并a和b所在的两个集合：

维护size并查集

int p[N], size[N];
//p数组存储每个点的祖宗节点, size[]只有祖宗节点的有意义，表示祖宗节点所在集合中的点的数量

int find(int x) // 返回x的祖宗节点
{
	if (p[x] != x) p[x] = find(p[x]);
	return p[x];
}

for (int i = 1; i <= n; i ++ ) // 初始化，假定节点编号是1~n
{
	p[i] = i;
	size[i] = 1;
}

size[find(b)] += size[find(a)]; // 合并a和b所在的两个集合：
p[find(a)] = find(b);

哈希表

拉链法

int h[N], e[N], ne[N], idx;

void insert(int x) //插入数据
{
    int k = (x % N + N) % N; //哈希函数，N一般取100003
    e[idx] = x;
    ne[idx] = h[k];
    h[k] = idx ++ ;
}

bool find(int x) //查找数据
{
    int k = (x % N + N) % N;
    for (int i = h[k]; i != -1; i = ne[i])
    {
        if (e[i] == x) return true;
    }
    return false;
}

字符串哈希

求哈希值

for (int i = 1; i <= n; i ++ ) //s为字符串，P为进制，一般取131
{
	p[i] = p[i - 1] * P; //各数位上的进位
	h[i] = h[i - 1] * P + s[i]; //哈希值
}

返回指定区间的哈希值，若两区间哈希值相等，说明字符串相等

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

树状数组

int tr[N];

int lowbit(int x)
{
    return x & -x;
}

void add(int a, int b)
{
    for (int i = a; i <= n; i += lowbit(i))
        tr[i] += b;
}

int query(int a)
{
    int res = 0;
    for (int i = a; i; i -= lowbit(i))
        res += tr[i];
    return res;
}

其它总结

1. map
   map是一个关联容器，它提供一对一的hash。
   第一个可以称为关键字(key)，每个关键字只能在map中出现一次；
   第二个可能称为该关键字的值(value)。
   主要用法：
   插入： 通过下标mp[i] = i; 通过insert函数mp.insert(make_pair(i, i));
   读取和查找元素： 通过key值读取mp[key] 通过count(k)、find(k)分别返回k出现的次数和指向该元素的迭代器。
   删除： 通过erase函数 erase(k)k为key值或迭代器。
2. 用printf输出string类型时，需要用c_str()函数将其转换为char*类型。
3. 用reverse(s.begin() + i, s.begin() + i + k);函数翻转部分序列时，可看作翻转从下标为i到下标为i + k - 1之间的元素。
4. map和unordered_map的区别

	map	unordered_map
排序	是	否
实施	二叉搜索树	哈希表
查找	O(logn)	平均O(1)，最坏O(n)
插入	O(logn) + 再平衡时间	同查找
用处	需要一组排序后的数据	只需记录数据而不需排序

5. 注意检查语句顺序。
6. scanf读入字符数组时，注意长度+1，末尾有结束符。
7. 用strcmp(str1, str2) == 0判断两个字符数组是否相等，等于0则相等。
8. %*s表示跳过一个字符串，不做读入处理。
9. 领接表的定义：vector<vector<int>> g; 二维vector，使用前先用resize确定大小或在定义时确定大小。

本周拓展题

单调栈：Acwing600
单调队列：Acwing652
并查集：Acwing914
树状数组： Acwing1267
线段树： Acwing 245
tire树： Acwing161
单链表 ：Acwing1560
kmp：Acwing141
哈希表：Acwing1523