基础数据结构（完结）

基础数据结构

单链表

struct link{
    int head;
    struct node {
		int val, ne;
    }
    vector<node> a;
    link() {
        head = -1;
    }
    void insert(int x) {
        a.push_back({x , head});
        head = a.size() - 1;
    }
    void del(int idx) {
        a[idx].ne = a[a[idx].ne];
    }
    int find(int x) {
        int now = 0;
        while(now != -1) {
            if(a[now].val = x) return now;
            now = a[now].ne;
        }
    }
};

栈

struct stack {
    vector<int> a;
    bool empty() {
        return a.size() == 0;
    }
    int top() {
        if(!empty()) {
            return a.back();
        }
    }
    void push(int x) {
        a.push_back(x);
    }
    void pop() {
		if(!empty()) a.pop_back();
    }
};

队列

struct queue {
   	vector<int> a;
    int head = 0;
    bool empty() {
        return a.size() == head;
    }
    void push(int x) {
        a.push_back(x);
    }
    void fornt() {
        if(!empty()) {
            return a[head];
        }
    }
    void pop() {
        if(!empty()) head ++;
    }
    
};

并查集

struct DSU {
    int N;
    vector<int> pr;
    vector<int> rnk;
    DSU(int n) {
        N = n;
        pr.resize(N + 1);
        rnk.resize(N + 1);
        for(int i = 0 ; i <= N; i ++) {
            pr[i] = i;
            rnk[i] = 1;
        }
    }
    int root (int x) {
        return pr[x] == x ? x : pr[x] = root(pr[x]);
    }
    bool same(int a, int b) {
        return root(a) == root(b);
    }
    void unite(int a, int b) {
        int A = root(a), B = root(b);
        if(A == B) return;
        if(rnk[A] < rnk[B]) {
            pr[A] = B;
        }
        else {
            if(rnk[A] == rnk[B]) {
                rnk[A] ++;
            }
            pr[B] = A;
        }
    }
};

ST表

基于倍增的思想，利用动态规划来实现。常用来解决静态RMQ（区间最值问题）、GCD（区间最小公约数问题）等问题。预处理时间复杂度\(O(nlogn)\)，查询时间复杂度\(O(1)\)，空间复杂度\(O(nlogn)\)。
以RMQ问题为例我们将\([i,i + 2 ^ k - 1]\)这一段区间看成两段区间取最大值 \(max([i , i + 2 ^ {k - 1} - 1],[i + 2^{k - 1},i + 2 ^k - 1])\)，为检查这个做法的合理里，我们需要判断这样做是否能包含所有区间。我们对任意查询区间\([l,r]\)看作\(max([l,l + 2 ^ p],[r - 2 ^ p,r])\)其中\(p = {log_{2}{\lfloor r - l + 1\rfloor}}\)就可以满足整个区间为\([l,r]\)。现在我们用\(f(i,j)\)来表示\([i + 2^{j - 1},i + 2 ^j - 1]\)这段区间，那么\(max([l,l + 2 ^ p],[r - 2 ^ p,r])\)就可以表示为\(max(f(l, 2^p),f(r - 2 ^ p, 2^p))\)。

struct ST {
	vector<vector<int>> st;
    ST(vector<int> a) {
        int n = a.size();
        st.resize(n, vector<int>(log2(n) + 1));
        for(int i = 0; i < n; i ++) {
            st[i][0] = a[i];
        }
        for(int j = 1; j <= log2(n); j ++) {
            for(int i = 0; i + (1 << j) - 1 < n; i ++) {
                st[i][j] = max(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
            }
        }
    }
};

树状数组

树状数组一般用来维护单点修改，区间查询的静态数据结构。也可以扩展出区间修改、单点查询，区间修改、区间查询这些功能。

其中c数组管理的就是树状数组。
树状数组中的一个核心操作是\(lowbit(x)\)，即非负整数\(x\)在二进制表示下最低位\(1\)及其后面的\(0\)构成的数值，\(lowbit(\)x\() = x \& (-x)\)。我们发现对非祖宗节点\(c[x]\)来说，它的父亲节点就是\(c[x + lowbit(x)]\)。
考虑单点修改\(a_i = a_i+ d\)，那么应该一层一层向上找到父节点，并\(+d\)。

void add(int x, int d) {
    for(;x <= n; x += lowbit(x)) {
        c[x] += d;
    }
}

考虑求\(a_i\)的前缀和，那么应该不断地找左上角的节点，并累加。

int ask(int x) {
   int res = 0;
    for(;x; x -= lowbit(x)) {
        res += c[x];
    }
    return res;
}

类封装

struct BIT {
    int N;
    vector<int> c;
    int lowbit(int x) {
        return x & -x;
    }
    void add(int x, int d) {
        for(;x <= N; x += lowbit(x)) {
        	c[x] += d;
    	}
    }
    int ask(int x) {
       int res = 0;
        for(;x; x -= lowbit(x)) {
            res += c[x];
        }
        return res;
    }
    BIT(vector<int> a) : N(a.size()){
        c.resize(N);
        for(int i = 1;i < N;i ++) {
            add(i, a[i]);
        }
    }
};

线段树

单点修改，区间查询

const int M = 5e5 + 10;
int n, m, a[M], f[4 * M];
void build(int k, int l, int r) {
    if(l == r) {
        f[k] = a[l];
        return;
    }
    int m = l + r >> 1;
    build(k << 1, l, m);
    build(k << 1 | 1, m + 1, r);
    f[k] = f[k << 1] + f[k << 1 | 1];
}
void add(int k, int l, int r, int x, int y) {
    f[k] += y;
    if(l == r) {
        return;
    }
    int m = l + r >> 1;
    if(x <= m) {
        add(k << 1, l, m, x, y);
    } else {
        add(k << 1 | 1, m + 1, r, x, y);
    }
}
int ask(int k, int l, int r, int s, int t) {
    if(l == s && r == t) {
        return f[k];
    }
    int m = l + r >> 1;
    if (m >= t) {
        return ask(k << 1, l, m, s, t);
    } else if(m < s) {
        return ask(k << 1 | 1, m + 1, r, s, t);
    } else {
        return ask(k << 1, l, m, s, m) + a(k << 1 | 1, m + 1, r, m + 1, t);
    }
}

区间修改，区间查询

const int M = 1e5 + 10;
ll a[M], d[4 * M], v[4 * M];
int n, m;
void build(int k, int l, int r) {
    v[k] = 0;
    if(l == r) {
        d[k] = a[l];
        return ;
    }
    int m = l + r >> 1;
    build(k << 1 ,l , m);
    build(k << 1 | 1, m + 1, r);
    d[k] = d[k << 1] + d[k << 1 | 1];
}
void insert(int k, int l, int r, int x, int y, ll z) {
    if(l == x && r == y) {
        v[k] += z;
        return ;
    }
    d[k] += (y - x + 1) * z;
    int m = l + r >> 1;
    if(m >= y) {
        insert(k << 1, l, m, x, y, z);
    } else if(m < x) {
        insert(k << 1 | 1, m + 1, r, x, y, z);
    } else {
        insert(k << 1, l, m, x, m, z);
        insert(k << 1 | 1, m + 1, r, m + 1, y, z);
    }
}
ll ask(int k, int l, int r, int x, int y, ll p) {
    p += v[k];
    if(l == x && r == y) {
        return (y - x + 1) * p + d[k]; 
    }
    int m = l + r >> 1;
    if(m >= y) {
        return ask(k << 1, l, m, x, y, p);
    } else if(m < x) {
        return ask(k << 1 | 1,m + 1, r, x, y, p);
    } else {
        return ask(k << 1, l, m, x, m, p) + ask(k << 1 | 1, m + 1, r, m + 1, y , p);
    }
}

字典树Tire

const int N = 1e5, M = 26;
struct Tire {
    int idx;
    vector<vector<int>> tr;
    vector<int> cnt;
    Tire() {
        idx = 0;
        tr.resize(N, vector<int> (M));
        cnt.resize(N);    
    }
	void add(string s) {
        int p = 0;
        for(int i = 0; i < s.size(); i ++) {
            int u = s[i] - 'a';
            if(!tr[p][u]) {
                tr[p][u] = ++ idx;
            }
            p = tr[p][u];
        }
        cnt[p] ++;
    }
    int query(string s) {
        int p = 0;
        for(int i = 0; i < s.size(); i ++) {
            int u = s[i] - 'a';
            if(!tr[p][u]) return 0;
            p = tr[p][u]; 
        }
        return cnt[p];
    }
};

01tire

const int N = 1e7;
struct Tire {
    int idx;
    int tr[N][2];
    Tire() {
        idx = 0;
        memset(tr, 0, sizeof tr);
    }
	void add(int x) {
        int p = 0;
        for(int i = 30; i >= 0; i --) {
            int u = x >> i & 1;
            if(!tr[p][u]) {
                tr[p][u] = ++idx;
            }
            p = tr[p][u];
        }
    }
    bool query(int x) {
        int p = 0;
        for(int i = 30; i >= 0; i --) {
            int u = x >> i & 1;
            if(!tr[p][u]) return 0;
            p = tr[p][u];
        }
        return 1;
    }
    int querymx(int x) {
        int p = 0, res = 0;
        for(int i = 30; i >= 0; i --) {
            int u = x >> i & 1;
            if(tr[p][!u]) {
                res += 1 << i;
                p = tr[p][!u];
            } else {
                p = tr[p][u];
            }
        }
        return res;
    }
    int querymi(int x) {
        int p = 0, res = 0;
        for(int i = 30; i >= 0; i --) {
            int u =  x >> i & 1;
            if(tr[p][u]) {
                p = tr[p][u];
            } else {
                p = tr[p][!u];
                res += 1 << i;
            }
        }
        return res;
    }
};