Trie树、并查集、堆

Trie树

用来高效地存储和查找字符串集合的数据结构
使用Trie树通常存储要么全是小写、要么全是大写、要么全是数字
Trie字符串统计

import java.util.*;

class Main{
    
    static int N = 100010;
    static int[][] son = new int[N][26];
    static int[] cnt = new int[N];
    static int idx = 0;
    
    
    public static void insert(char[] str){
        int p = 0;
        for(int i = 0; i < str.length; i++){
            int u = str[i] - 'a';
            if(son[p][u] == 0) son[p][u] = ++idx;
            p = son[p][u];
        }
        cnt[p]++;
    }
    
    public static int query(char[] str){
        int p = 0;
        for(int i = 0; i < str.length; i++){
            int u = str[i] - 'a';
            if(son[p][u] == 0) return 0;
            else p = son[p][u];
        }
        return cnt[p];
    }
    
    
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        in.nextLine();
        while(n-- > 0){
            String[] ops = in.nextLine().split(" ");
            if(ops[0].equals("I")){
                insert(ops[1].toCharArray());
            }else{
                int res = query(ops[1].toCharArray());
                System.out.println(res);
            }
        }
    }
}

并查集

两大主要功能：

1. 将两个集合合并
2. 询问两个元素是否在一个集合当中
   并且近乎O(1)的时间复杂度内完成。

基本原理：
每个集合用一棵树来表示，树根的编号就是整个集合的编号，每个节点存储它的父节点，p[x]表示x的父节点。

问题1: 如何判断树根？ --〉if(p[x] == x)
问题2: 如何求集合编号？ --〉while(p[x] != x) x = p[x]最后这个x就是集合编号
问题3: 如何合并两个集合？ --〉设px是x的集合编号， py是y的集合编号。p[x] = y

常用优化：
路径压缩

import java.util.*;

class Main{
    static int N = 100010;
    static int[] p = new int[N]; //每个节点存储它的父节点
    
    public static int find(int a){
        if(p[a] != a) p[a] = find(p[a]);
        return p[a];
    }
    
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        for(int i = 1; i <= n; i++) p[i] = i;
        in.nextLine();
        while(m-- > 0){
            String[] ops = in.nextLine().split(" ");
            int a = Integer.parseInt(ops[1]), b = Integer.parseInt(ops[2]);
            if(ops[0].equals("M")){
                p[find(a)] = find(b);
            }else{
                System.out.println(find(a) == find(b) ? "Yes" : "No");
            }
        }
        
    }
    
    
    
}

堆

小根堆：每个点的值都小于左右两个儿子的值
堆的存储方式：用一维数组存下一棵树。根节点编号为1，对于x的左儿子：2x，右儿子：2x+1
down操作是当前下标的数，太大了，需要往下移动，up操作数当前下标的数太小了，需要往上移动。

如何手写一个堆？注意用数组模拟堆的话，下标需要从1开始。（因为0的左儿子2*0还是0，冲突了）

1. 插入一个数：heap[++size] = x; up(size);
2. 求集合中的最小值：heap[1];
3. 删除最小值：heap[1] = heap[size]; size--; down(1);就是把队尾的数覆盖到队头，然后再把队尾的数删掉，然后重新down
4. 删除任意一个元素：heap[k] = heap[size]; size--; down(k); up(k);不知道删掉的数比队尾的数大还是小，所以干脆down一次up一次，确保调整好了次序，但实际上必然只会执行一个操作。
5. 修改任意一个元素：heap[k] = x; down(k); up(k);