算法题代码模板2

// 静态单链表
int head, e[N], ne[N], idx;

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

// 头插
void insert(int x) {
    e[idx] = x, ne[idx] = head, head = idx++;
}

void remove() {
    head = ne[head];
}

// 栈
int stk[N], top = -1;

stk[++top] = x; // 入栈
--top;  //出栈
top == -1 // 栈是否为空
stk[top]  //访问栈顶元素


// 普通队列
int q[N], front = 0, rear = 0;

q[rear++] = x; // 入队
++front;  // 出队
front == rear // 队列是否为空
q[front]  //访问队列最前面元素

// 循环队列
int q[N], front = 0, rear = 0;

q[rear++] = x;  if(rear == N) rear = 0;   // 入队
++front; if(front == N) front = 0;  // 出队
front == rear // 队列是否为空
q[front]  //访问队列最前面元素


// 单调栈 经常用来找左边/右边第一个大于/小于它的数字/下标
// 这里建议用来存下标，更通用
int stk[N], top = -1;
for (int i = 0; i < n; ++i) {
    while(top != -1 && check(a[stk[top]], a[i])) --top;
    stk[++top] = i;

    //.....
}

// 单调队列 如滑动窗口，用来找窗口内最大/最小值
int q[N], front = 0, rear = 0;
for(int i = 0; i < n; ++i) {
    while(front != rear && q[rear - 1] > num[i]) --rear;
    q[rear++] = num[i];
    if (i >= k - 1) {
        printf("%d ", q[front]);
        if (q[front] == num[i - k + 1]) ++front;
    }
}


// KMP



// Trie
int son[N][26], cnt[N], idx;

void insert(string& s) {
    int p = 0;
    for(auto c: s) {
        int u = c - 'a';
        if (son[p][u]) son[p][u] = ++idx;
        p = son[p][u];
    }
    cnt[p]++;
}

int query(string& s) {
    int p = 0;
    for(auto c: s) {
        int u = c - 'a';
        if (!son[p][u]) return 0;
        p = son[p][u];
    }
    return cnt[p];
}

// 朴素并查集
int p[N];
void init() {
    for(int i = 0; i < N; ++i) p[i] = i;
}

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

void connect(int a, int b) {
    p[find(a)] = find(b);
}

// 维护size的并查集
int p[N], size[N];

void init() {
    for(int i = 0; i < N; ++i)
        p[i] = i, size[i] = 1;
}

int find(int x) {
    if (p[x] == x) return x;
    else return p[x] = find(p[x]);
}

void connect(int a, int b) {
    p[find(a)] = find(b);
    size[find(b)] += size[find(a)];
}

// 维护到根节点距离
int p[N], dist[N];
void init() {
    for(int i = 0; i < N; ++i)
        p[i] = i, dist[i] = 0;
}

int find(int x) {
    if (x == p[x]) return x;
    int pp = p[x];
    p[x] = find(pp);
    dist[x] += dist[pp];
}

void connect(int a, int b, int d) {
    p[find(a)] = find(b);
    dist[find(a)] = d;
}


// 小根堆 这里除了维护值，还维护了其他信息，根据需要取舍
// 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(h[a], h[b]);
    swap(hp[a], hp[b]);
    swap(ph[hp[a]], ph[hp[b]]);
}

void down(int u) {
    int t = u, son = 2 * u;
    while(son < n) {
        if (son + 1 < n && h[son + 1] < h[son]) ++son;
        if (h[son] > h[t]) break;
        head_swap(t, son);
        t = son, son = 2 * son;
    }
}

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

void build_heap() {
    for(int i = n / 2; i ; i--)
        down(i);
}

// 哈希 拉链 一般不会用到
int h[N], e[N], ne[N], idx;
void init() {
    memset(h, -1, sizeof(h));
    idx = 0;
}

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

bool find(int x) {
    int k = hash(x);
    int p = h[k];
    while(p != -1 && e[p] != x)
        p = ne[p];
    return p != -1;
}

// 字符串哈希
using ULL = unsigned long long;
ULL h[N], p[N];

p[0] = 1;
for(int i = 1; i <= n; ++i) {
    h[i] = h[i - 1] * P + str[i];
    P[i] = P[i - 1] * P;
}

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