初级数据结构模板（持续更新中~~~）

/*单链表 head其实就是一个指针，是一个特殊的指针罢了。
  刚开始的时候它负责指向空结点，在链表里有元素的时候，它变成了一个指向第一个元素的指针
         e[]存储节点的数值
         ne[]存储节点的next指针
 

idx在我看来扮演两个角色：

1.在一开始时，作为链表的下标。
2.在链表进行各种插入，删除等操作时，作为一个临时的辅助性的所要操作的元素的下标来帮助操作。并且是在每一次插入操作的时候，给插入元素一个下标，给他一个窝，感动！*/
        
int head , e[N] , ne[N] , idx;

void init()
{
    head = -1 ;
    idx = 0;
}

void inert_head(int x)
{
    e[idx] = x;
    ne[idx] = head;
    head = idx ++;
}

void insert(int l , int x)
{
    e[idx] = x;
    ne[idx] = ne[k];
    ne[k] = idx ++ ;
}

void remove(int k)
{
    ne[k] = ne[ne[k]];
}

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//双链表 l[]表示节点的左指针  r[]表示节点的右指针 

void init()
{   //0是左端点 1是右端点
    r[0] = 1 , l[1] = 0;
    idx = 2;
}

void insert(int k , int x)
{
    e[idx] = x;
    l[idx] = k , r[idx] = r[k];
    l[r[k]] = idx;
    r[k] = idx ++ ;
}

void del(int a)
{
    l[r[a]] = l[a];
    r[l[a]] = r[a];
}

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//模拟栈 tt表示栈顶

int stk[N] , tt = 0;

//向栈顶插入一个数   栈顶所在索引往后移动一格，然后放入x

stk[ ++ tt ] = x;

//从栈顶弹出一个数

tt -- ;

//栈顶的值

stk[tt];

//判断栈是否为空

if(tt > 0){}

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//模拟队列 hh是队头 tt是队尾  尾进头出！！
int q[N] , hh = 0 ; tt = -1;

//向队尾插入一个数
q[ ++ tt ] = x;

//从队头弹出一个数
hh ++;

//队头的值
q[hh];

//判断对列是否为空

if(hh <= tt)    //包含hh == tt

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//循环队列 hh表示队头 tt表示队尾的最后一个位置
int q[N] , hh = 0 , tt = 0;

//向队尾插入一个数
q[tt ++] = x;
if(tt = N) tt = 0;  //循环！后面用完了，补到前面

//从队头弹出一个数
hh ++;
if(hh == N) hh = 0;

//队头的值
q[hh];

//判断队列是否为空
if(hh != tt)

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//单调栈 ： 常见题型 ：找出每个数左边离他最近的最大（小）的数
int tt = 0;
for(int i = 1 ; i <= n ; i ++)        //！！！！方法：回忆动态图！！！！
{
    while(tt && check(stk[tt] , i)) tt --;  //如果tt不是0且栈顶元素大于（小于）i那么栈顶元素肯定不是答案
    stk[ ++ tt ] = i;
}

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//单调队列 经典题型：找出滑动窗口中的最大最小值
/*思路：最小值和最大值分开来做，两个for循环完全类似，都做以下四步：

        1.解决队首已经出窗口的问题;
        2.解决队尾与当前元素a[i]不满足单调性的问题;
        3.将当前元素下标加入队尾;
        4.如果满足条件则输出结果;
需要注意的细节：

        1.上面四个步骤中一定要先3后4，因为有可能输出的正是新加入的那个元素;
        2.队列中存的是原数组的下标，取值时要再套一层，a[q[]];
        3.算最大值前注意将hh和tt重置;
        4.此题用cout会超时，只能用printf;
        5.hh从0开始，数组下标也要从0开始。
*/
int hh = 0 , tt = -1;
for(int i = 0 ; i < n ; i ++)
{
    while(hh <= tt && check_out(q[hh])) hh ++;  //维持滑动窗口的大小
    while(hh <= tt && check(q[tt] , i)) tt --;  /*当队列不为空(hh <= tt) 且 
                                                  当队列队尾元素？当前元素(a[i])时,
                                                  那么队尾元素就一定不是当前窗口最？值,
                                                  删去队尾元素,加入当前元素*/
    q[ ++ tt ] = i;
}

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//KMP
/*每一个字符前的字符串都有最长相等前后缀，而且最长相等前后缀的长度是我们移位的关键，
  所以我们单独用一个next数组存储子串的最长相等前后缀的长度。而且next数组的数值只与子串本身有关。
  所以next[i]=j,含义是：1.下标为i 的字符前的字符串最长相等前后缀的长度为j。
                        2.表示该处字符不匹配时应该回溯到的字符的下标为j
                          且next[0]=-1 */

//s[]是母串 p[]是子串，n是s的长度，m是p的长度

//求next数组 （模板串自己与自己匹配）

for(int i = 2 , j = 0 ; i <= m ; i ++)
{
    while(j && p[i] != p[j + 1])j = ne[j];
    if(p[i] == p[j + 1])j ++;
    ne[i] = j;
}

/*匹配
  s[ a , b ] = p[ 1, j ] && s[ i ] != p[ j + 1 ] 
  此时要移动p串（不是移动1格，而是直接移动到下次能匹配的位置）
  其中1串为[ 1, next[ j ] ]，3串为[ j - next[ j ] + 1 , j ]。
  由匹配可知 1串等于3串，3串等于2串。所以直接移动p串使1到3的位置即可。
  这个操作可由j = next[ j ]直接完成。 如此往复下去，当 j == m时匹配成功。*/

for(int i = 1, j = 0; i <= n; i++)
{
    while(j && s[i] != p[j+1]) j = ne[j];
    //如果j有对应p串的元素， 且s[i] != p[j+1], 则失配， 移动p串
    //用while是由于移动后可能仍然失配，所以要继续移动直到匹配或整个p串移到后面（j = 0)

    if(s[i] == p[ j + 1 ]) j++;
    //当前元素匹配，j移向p串下一位
    if(j == m)
    {
        //匹配成功，进行相关操作
        j = next[j];  //继续匹配下一个子串
    }
}

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//trie树 （字典树）

//插入
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] ++; //结束时的标记，也是记录以此节点结束的字符串个数
}

//查找

int query(char*str)
{
    int q = 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];//返回字符串出现的次数
}

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//并查集
/*find函数：
find(1) p[1] = 2  p[1] = find(2)
find(2) p[2] = 3  p[2] = find(3)
find(3) p[3] = 4  p[3] = find(4)
find(4) p[4] = 4  将p[4]返回

退到上一层
find(3) p[3] = 4  p[3] = 4 将p[3]返回
退到上一层
find(2) p[2] = 3  p[2] = 4 将p[2]返回
退到上一层
find(1) p[1] = 2  p[1] = 4 将p[1]返回

至此，我们发现所有的1，2，3的父节点全部置为了4，实现路径压缩；同时也实现了1的父节点的返回  */

/*
合并1， 5
find(1) = 3 find(5) = 4
p[find(1)] = find(5) –> p[3] = 4
*/

//朴素
    int p[N]; //存储每个点的祖宗节点
    
    int find(int x)
    {
        if(p[x] != x) p[x] = find(p[x]);  //递归查找祖宗节点
        return p[x];
    }

    //初始化，假设节点编号是1 - n
    for(int i = 1 ; i <= n ; i ++) p[i] = i;
    
    p[find(a)] = find(b); //将合并到b上

//维护size的并查集
  
    int p[N] , size[N]; //size[find（x）] 只对祖宗节点有意义 表示祖宗节点所在集合中的点的数量
    
    int find(int x)// 返回x的祖宗节点
    {
        if(p[x] != x) p[x] = find(p[x]);
        return p[x];
    } 
    
    // 初始化，假定节点编号是1~n
    for(int i = 1 ; i <= n ; i ++)
    {
        p[i] = i;
        size[i] = 1;
    }
    
    // 合并a和b所在的两个集合：
    size[find(b)] += size[find(a)];
    p[find(a)] = find(b);

//维护到祖宗距离的并查集
   int p[N] , d[N]; //d[x]存储x到p[x]的距离
   
   int find(int x)
   {
       if(p[x] != x)
       {
           int u = find(p[x]);
           d[x] += d[p[x];
           p[x] = u
       }
       return p[x];
   }

    for(int i = ; i <= n ; i ++)
    {
        p[i] = i;
        d[i] = 0;
    }

    p[find(a)] = find(b);
    d[find(b)] = distence;// 根据具体问题，初始化find(a)的偏移量

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

/* 从n/2开始down: 因为n是最大值，n/2是n的父节点，因为n是最大，
   所以n/2是最大的有子节点的父节点,所以从n/2往前遍历，就可以把整个数组遍历一遍*/

// h[N]存储堆中的值, h[1]是堆顶，x的左儿子是2x, 右儿子是2x + 1
// ph[k]存储第k个插入的点在堆中的位置
// hp[k]存储堆中下标是k的点是第几个插入的
int h[N], ph[N], hp[N], size;

// 交换两个点，及其映射关系
void heap_swap(int a, int b)
{
    swap(ph[hp[a]],ph[hp[b]]);
    swap(hp[a], hp[b]);
    swap(h[a], h[b]);
}

void down(int u)
{
    int t = u;
    if (u * 2 <= size && h[u * 2] < h[t]) t = u * 2;
    if (u * 2 + 1 <= size && h[u * 2 + 1] < h[t]) t = u * 2 + 1;
    if (u != t)
    {
        heap_swap(u, t);
        down(t);
    }
}

void up(int u)
{
    while (u / 2 && h[u] < h[u / 2])
    {
        heap_swap(u, u / 2);
        u >>= 1;
    }
}

// O(n)建堆
for (int i = n / 2; i; i -- ) down(i);

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

/* 如何理解单(双)链表，Trie树和堆中的idx？
1.idx的操作总是idx++，这就保证了不同的idx值对应不同的结点，这样就可以利用idx把结构体内两个属性联系在一起了。
  因此，idx可以理解为结点。 idx相当于一个分配器，如果需要加入新的结点就用++idx分配出一个下标*/

//简单哈希

//拉链法
    int h[N] , e[N] , ne[N] , idx;
    
    //向哈希表插入一个数
    void insert(int x)
    {
        int k = (x % N + N) % N;
        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;
    }
    
//开放寻址法
int h[N];

int find(int x)   // 如果x在哈希表中，返回x的下标；如果x不在哈希表中，返回x应该插入的位置
{
    int t = (x % N + N) % N;
    while(h[t] != null && h[t] != x)
    {
        t ++ ;
        if(t == N) t = 0;
    }
    return t;
}

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//字符串哈希法(非常nb的方法)
/*1.把字符串变成一个p进制数字（哈希值），实现不同的字符串映射到不同的数字。
  2.对形如 X1 X2 X3 ⋯ Xn−1 Xn X1 X2 X3 ⋯ Xn−1 Xn 的字符串,采用字符的ascii 码乘上 P 的次方来计算哈希值。
    映射公式 (X1×Pn−1+X2×Pn−2+⋯+Xn−1×P1+Xn×P0)modQ
  注意点：
1. 任意字符不可以映射成0，否则会出现不同的字符串都映射成0的情况，比如A,AA,AAA皆为0
2. 冲突问题：1通过巧妙设置P (131 或 13331) , Q (264)(264)的值，一般可以理解为不产生冲突。*/

/*前缀和公式 h[i+1]=h[i]×P+s[i] i∈[0,n−1] h为前缀和数组，s为字符串数组
  区间和公式 h[l,r]=h[r]−h[l−1]×P^r−l+1                                       */

//核心思想：将字符串看成P进制数，P的经验值是131或13331，取这两个值的冲突概率低
//小技巧：取模的数用2^64，这样直接用unsigned long long存储，溢出的结果就是取模的结果