From 7c52a3c53838449dc1fe43985e2ed9f960bf1f63 Mon Sep 17 00:00:00 2001 From: newbie Date: Sat, 6 Jan 2024 10:59:58 +0800 Subject: [PATCH] update --- snippets/acm/Class_Data.code-snippets | 303 +++++++++++++++++++++ snippets/acm/Class_Graph.code-snippets | 359 +++++++++++++++++++++++++ snippets/acm/Class_Math.code-snippets | 108 ++++++++ 3 files changed, 770 insertions(+) create mode 100644 snippets/acm/Class_Data.code-snippets create mode 100644 snippets/acm/Class_Graph.code-snippets create mode 100644 snippets/acm/Class_Math.code-snippets diff --git a/snippets/acm/Class_Data.code-snippets b/snippets/acm/Class_Data.code-snippets new file mode 100644 index 0000000..bc82d63 --- /dev/null +++ b/snippets/acm/Class_Data.code-snippets @@ -0,0 +1,303 @@ +{ + "Class_Array_tree": { + "prefix": "Class_Array_tree", + "body": [ + "", + "template ", + "class Array_tree {", + " public:", + " Array_tree() {}", + " Array_tree(int n) { this->n = n, tree = vector(n + 1); }", + " void add(int id, T key) {", + " for (int i = id; i <= n; i += lowbit(i)) tree[i] += key;", + " }", + "", + " T get_sum(int id) {", + " T sum = 0;", + " for (int i = id; i; i -= lowbit(i)) sum += tree[i];", + " return sum;", + " }", + "", + " T get_sum(int l, int r) { return get_sum(r) - get_sum(l - 1); }", + "", + " private:", + " int n;", + " vector tree;", + " int lowbit(int x) { return x & -x; }", + "};", + "" + ] + }, + "Class_SGM_Tree": { + "prefix": "Class_SGM_Tree", + "body": [ + "", + "class SGM_Tree {", + " public:", + " class point {", + " public:", + " ll sum, maxi, mini;", + " };", + "", + " vll a, lazy;", + " int n;", + " ll sum, maxi, mini;", + " vector tree;", + "", + " SGM_Tree() {}", + " SGM_Tree(int n, vi v) {", + " // a下标默认从1开始,只需开n个点，不需要n + 1", + " this->n = n;", + " lazy = vll(n * 4 + 1);", + " a.push_back(0);", + " for (int i = 1; i <= n; i++) a.push_back(v[i]);", + " tree = vector(4 * n + 1), build(1, n, 1);", + " }", + " SGM_Tree(int n, vll v) {", + " // a下标默认从1开始,只需开n个点，不需要n + 1", + " this->n = n;", + " lazy = vll(n * 4 + 1);", + " a.push_back(0);", + " for (int i = 1; i <= n; i++) a.push_back(v[i]);", + " tree = vector(4 * n + 1), build(1, n, 1);", + " }", + " SGM_Tree(int n, int* v) {", + " // a下标默认从1开始,只需开n个点，不需要n + 1", + " this->n = n;", + " lazy = vll(n * 4 + 1);", + " a.push_back(0);", + " for (int i = 1; i <= n; i++) a.push_back(v[i]);", + " tree = vector(4 * n + 1), build(1, n, 1);", + " }", + "", + " void push_up(int k) {", + " int l = k * 2, r = k * 2 + 1;", + " tree[k].sum = tree[l].sum + tree[r].sum;", + " tree[k].maxi = max(tree[l].maxi, tree[r].maxi);", + " tree[k].mini = min(tree[l].mini, tree[r].mini);", + " }", + "", + " void push_down(int l, int r, int k) {", + " if (lazy[k]) {", + " int mid = l + r >> 1;", + " lazy[k * 2] += lazy[k];", + " lazy[k * 2 + 1] += lazy[k];", + " tree[k * 2].sum += lazy[k] * (mid - l + 1);", + " tree[k * 2 + 1].sum += lazy[k] * (r - mid);", + " tree[k * 2].maxi += lazy[k];", + " tree[k * 2 + 1].maxi += lazy[k];", + " tree[k * 2].mini += lazy[k];", + " tree[k * 2 + 1].mini += lazy[k];", + " lazy[k] = 0;", + " }", + " }", + "", + " void get_updata(int l, int r, int k, ll value) {", + " tree[k].sum += value * (r - l + 1);", + " tree[k].maxi += value;", + " tree[k].mini += value;", + " lazy[k] += value;", + " }", + "", + " void get(int k) {", + " sum += tree[k].sum;", + " maxi = max(maxi, tree[k].maxi);", + " mini = min(mini, tree[k].mini);", + " }", + "", + " void build(int l, int r, int k) {", + " if (l == r) {", + " tree[k].maxi = tree[k].mini = tree[k].sum = a[l];", + " return;", + " }", + " int mid = l + r >> 1;", + " build(l, mid, k * 2);", + " build(mid + 1, r, k * 2 + 1);", + " push_up(k);", + " }", + "", + " void updata(int l, int r, int L, int R, int k, ll value) {", + " if (L <= l && r <= R) {", + " get_updata(l, r, k, value);", + " return;", + " }", + " push_down(l, r, k);", + " int mid = l + r >> 1;", + " if (L <= mid) updata(l, mid, L, R, k * 2, value);", + " if (R > mid) updata(mid + 1, r, L, R, k * 2 + 1, value);", + " push_up(k);", + " }", + "", + " void query(int l, int r, int L, int R, int k) {", + " if (L <= l && r <= R) {", + " get(k);", + " return;", + " }", + " push_down(l, r, k);", + " int mid = l + r >> 1;", + " if (mid >= L) query(l, mid, L, R, 2 * k);", + " if (mid < R) query(mid + 1, r, L, R, 2 * k + 1);", + " }", + "", + " ll get_sum(int L, int R) {", + " sum = 0;", + " query(1, n, L, R, 1);", + " return sum;", + " }", + "", + " ll get_max(int L, int R) {", + " maxi = -inf;", + " query(1, n, L, R, 1);", + " return maxi;", + " }", + "", + " ll get_min(int L, int R) {", + " mini = inf;", + " query(1, n, L, R, 1);", + " return mini;", + " }", + "};", + "" + ] + }, + "Class_Dsu": { + "prefix": "Class_Dsu", + "body": [ + "", + "class Dsu {", + " public:", + "", + " vll fa, num;", + "", + " Dsu(int n) { fa = vll(n + 1), num = vll(n + 1); }", + " int find(int x) {", + " if (!fa[x]) return x;", + " return fa[x] = find(fa[x]);", + " }", + "", + " bool Dunion(int p, int q) {", + " int v = find(p), u = find(q);", + " if (v == u) return 0;", + " fa[u] = v;", + " num[v] += num[u];", + " num[u] = num[v];", + " return 1;", + " }", + " ", + "};", + "", + "ll num(int x) { return num[find(x)]; }", + "" + ] + }, + "class_Stmap": { + "prefix": "Class_StMap", + "body": [ + "", + "class st_map {", + " public:", + " st_map() {}", + " st_map(vll v) {", + " this->n = v.size(), this->a = v;", + " this->st = vector>(n + 1);", + " st_init();", + " }", + " int query(int l, int r) {", + " int len = r - l + 1;", + " int k = log(len) / log(2);", + " return max(st[l][k], st[r - (1 << k) + 1][k]);", + " }", + "", + " private:", + " int n;", + " vll a;", + " vector> st;", + " void st_init() {", + " for (int j = 0; j <= 17; j++) {", + " for (int i = 1; i + (1 << j) - 1 <= n; i++) {", + " if (j == 0)", + " st[i][j] = a[i];", + " else", + " st[i][j] = max(st[i][j - 1], st[i + (1 << j - 1)][j - 1]);", + " }", + " }", + " }", + "};", + "" + ] + }, + "Class_HJT_tree": { + "prefix": "Class_HJT_tree", + "body": [ + "", + "template ", + "class HJT_tree {", + " //处理数据默认下标从1开始", + " public:", + " //构造函数", + " HJT_tree() {}", + " HJT_tree(vector v) {", + " base = v, this->n = base.size() - 1;", + " tree = vector(n * 32), root.push_back(build(1, n));", + " }", + "", + " void updata(int v, int x, T value) {", + " //插入函数(版本，修改位置，修改值)", + " root.push_back(insert(root[v], 1, n, x, value));", + " }", + "", + " T query(int v, int x) {", + " //查询函数（版本，查询位置）", + " return get_se(root[v], 1, n, x, x);", + " }", + "", + " T query(int v, int l, int r) {", + " //查询函数（版本，查询区间）", + " return get_se(root[v], 1, n, l, r);", + " }", + "", + " private:", + " vi root;", + " vector base;", + " int n, idx = 0;", + " struct node {", + " int l, r;", + " T data;", + " };", + " vector tree;", + " void pushup(int q) { tree[q].data = op(tree[q].l, tree[q].r); }", + " T op(int l, int r) { return max(tree[l].data, tree[r].data); }", + " T e() { return -inf; }", + " int build(int l, int r) {", + " int now = ++idx, mid = l + r >> 1;", + " if (l != r)", + " tree[now].l = build(l, mid), tree[now].r = build(mid + 1, r), pushup(now);", + " return now;", + " }", + " int insert(int old, int l, int r, int x, int value) {", + " int now = ++idx, mid = l + r >> 1;", + " tree[now] = tree[old];", + " if (l == r)", + " tree[now].data = value;", + " else {", + " if (x <= mid)", + " tree[now].l = insert(tree[old].l, l, mid, x, value);", + " else", + " tree[now].r = insert(tree[old].r, mid + 1, r, x, value);", + " pushup(now);", + " }", + " return now;", + " }", + " T get_se(int v, int l, int r, int L, int R) {", + " if (L <= l && r <= R) return tree[v].data;", + " ll mid = l + r >> 1;", + " T res = e();", + " if (L <= mid) res = max(res, get_se(tree[v].l, l, mid, L, R));", + " if (R > mid) res = max(res, get_se(tree[v].r, mid + 1, r, L, R));", + " return res;", + " }", + "};", + "" + ] + } +} diff --git a/snippets/acm/Class_Graph.code-snippets b/snippets/acm/Class_Graph.code-snippets new file mode 100644 index 0000000..8d9685c --- /dev/null +++ b/snippets/acm/Class_Graph.code-snippets @@ -0,0 +1,359 @@ +{ + "Graph": { + "prefix": "Class_Graph", + "body": [ + "", + "template ", + "class Graph {", + " public:", + " struct edge {", + " int next, to;", + " T w;", + " };", + " int n;", + " vector> maps;", + " vector dis;", + " vector e;", + " vi head, bj;", + " Graph() {}", + "", + " Graph(int n) {", + " this->n = n, this->m = n * (n - 1);", + " head = vi(n + 1, -1), e = vector(m * 2 + 1);", + " }", + "", + " Graph(int n, int m) {", + " this->n = n, this->m = m, head = vi(n + 1, -1), e = vector(m * 2 + 1);", + " }", + "", + " void add(int u, int v, T w) {", + " e[cnt].to = v, e[cnt].next = head[u], e[cnt].w = w, head[u] = cnt++;", + " }", + "", + " void add(int u, int v) {", + " e[cnt].to = v, e[cnt].next = head[u], head[u] = cnt++;", + " }", + "", + " private:", + " int m, cnt = 0;", + "};", + "#define e g.e", + "#define head g.head", + "#define maps g.maps", + "#define add g.add", + "", + ], + }, + "Class_Graph_Dijkstra": { + "prefix": "Class_Graph_Dijkstra", + "body": [ + "", + "#define dis g.dis", + "#define bj g.bj", + "ll dijkstra(Graph g, int st, int en) {", + " dis = vll(g.n + 1, inf),", + " bj = vi(g.n + 1);", + " priority_queue, greater> q;", + " dis[st] = 0;", + " q.push({0, st});", + " while (!q.empty()) {", + " int u = q.top().y;", + " q.pop();", + " if (bj[u]) continue;", + " bj[u] = 1;", + " for (int i = head[u]; ~i; i = e[i].next) {", + " int v = e[i].to;", + " if (dis[v] > dis[u] + e[i].w) {", + " dis[v] = dis[u] + e[i].w;", + " q.push({dis[v], v});", + " }", + " }", + " }", + " if (dis[en] != inf)", + " return dis[en];", + " else", + " return -1;", + "}", + "", + ], + }, + "Class_Graph_SPFA": { + "prefix": "Class_Graph_SPFA", + "body": [ + "", + "ll spfa(Graph g, int st, int en) {", + " vll bj(g.n + 1), dis(g.n + 1, inf), num(g.n + 1);", + " queue q;", + " dis[st] = 0;", + " bj[st] = 1;", + " q.push(st);", + " while (q.size()) {", + " int u = q.front();", + " if (!bj[u]) continue;", + " if (num[u] > g.n + 1) return inf;//判断是否产生负环", + " bj[u] = 0, num[u]++;", + " for (int i = head[u]; ~i; i = e[i].next) {", + " int w = e[i].w, v = e[i].to;", + " if (dis[v] > dis[u] + w) {", + " dis[v] = dis[u] + w;", + " if (!bj[v]) q.push(v);", + " }", + " }", + " }", + " if(dis[en] == inf) return -1;", + " return dis[en];", + "}", + "", + ], + }, + "Class_Graph_Kurskal": { + "prefix": "Class_Graph_Kurskal", + "body": [ + "", + "ll kruskal(Graph g, Dsu d) {", + " ll res = 0, cnt = 0;", + " sort(e.begin(), e.end());", + " for (auto i : e) {", + " int u = i.u, v = i.v, w = i.w;", + " int q = d.find(i.u), p = d.find(i.v);", + " if (d.Dunion(q, p)) cnt++, res += w;", + " if (cnt == n - 1) break;", + " }", + " return res;", + "}", + "", + ], + }, + "Class_Graph_Prim": { + "prefix": "Class_Graph_Prim", + "body": [] + }, + "Class_Graph_TreeDiam": { + "prefix": "Class_Graph_TreeDiam", + "description": "树的直径", + "body": [ + "ll TreeDiam(Graph g) {", + " vll dis1(n + 1), dis2(n + 1), p(n + 1), up(n + 1);", + " function dfs = [&](ll u, ll fa) {", + " for (int i = head[u]; ~i; i = e[i].next) {", + " int v = e[i].to, w = 1;", + " if (v == fa) continue;", + " ll x = dfs(v, u) + 1;", + " if (x >= dis1[u])", + " dis2[u] = dis1[u], dis1[u] = x, p[u] = v;", + " else if (x >= dis2[u])", + " dis2[u] = x;", + " }", + " return dis1[u];", + " };", + " function dfs0 = [&](ll u, ll fa) {", + " for (int i = head[u]; ~i; i = e[i].next) {", + " int v = e[i].to, w = 1;", + " if (v == fa) continue;", + " if (p[u] == v)", + " up[v] = max(dis2[u], up[u]) + w;", + " else", + " up[v] = max(dis1[u], up[u]) + w;", + " dfs0(v, u);", + " }", + " };", + " dfs(1, -1), dfs0(1, -1);", + " ll ans = -1;", + " for (int i = 1; i <= n + m; i++) {", + " if (dis1[i] == dis2[i] && dis1[i] == 0)", + " ans = max(ans, up[i]);", + " else", + " ans = max(ans, max(up[i], dis1[i]));", + " }", + " return ans;", + "}", + ] + }, + "Class_Graph_SCC": { + "prefix": "Class_Graph_SCC", + "body": [ + "", + "class SCC {", + " public:", + " stack stk;", + " int timestamp = 0, scc_cnt = 0, n, m;", + " vll dfn, low, in_stk, Size, id;", + " Graph g;", + "", + " SCC() {}", + "", + " SCC(Graph g) {", + " this->n = g.n, this->m = g.m, this->g = g;", + " dfn = vll(n + 1, 0);", + " low = vll(n + 1, 0);", + " in_stk = vll(n + 1, 0);", + " Size = vll(n + 1, 0);", + " id = vll(n + 1, 0);", + " for (int i = 1; i <= n; i++)", + " if (!dfn[i]) tarjan(i);", + " }", + "", + " void tarjan(int u) {", + " dfn[u] = low[u] = ++timestamp;", + " stk.push(u), in_stk[u] = 1;", + " for (int i = head[u]; ~i; i = e[i].next) {", + " int v = e[i].to;", + " if (!dfn[v]) {", + " tarjan(v);", + " low[u] = min(low[u], low[v]);", + " } else if (in_stk[v])", + " low[u] = min(low[u], dfn[v]);", + " }", + " if (low[u] == dfn[u]) {", + " ++scc_cnt;", + " int v;", + " do {", + " v = stk.top();", + " stk.pop();", + " in_stk[v] = 0;", + " id[v] = scc_cnt;", + " Size[scc_cnt]++;", + " } while (v != u);", + " }", + " return;", + " }", + "};", + "", + ], + }, + "Class_Graph_Euler": { + "prefix": "Class_Graph_Euler", + "body": [ + "", + "vll din, dout;", + "", + "class Euler {", + " public:", + " int n, m;", + " Graph g;", + " vector used;", + " vll path;", + " Euler() {}", + " Euler(Graph g) {", + " this->n = g.n, this->m = g.m, this->g = g;", + " used = vector(n + 1);", + " }", + "", + " void dfs_u(int u) {", + " //无向图", + " for (long long &i = head[u]; i; i = e[i].next) {", + " long long j = i & 1 ? i + 1 : i - 1;", + " if(used[i]) {", + " i = e[i].next;", + " continue;", + " }", + " used[j] = used[i] = true;", + " int t = i / 2 + 1;", + " dfs_u(e[i].to);", + " path.push_back(t);", + " }", + " }", + "", + " void dfs_o(int u) {", + " // 有向图", + " for (long long &i = head[u]; i; i = e[i].next) {", + " if(used[i]) {", + " i = e[i].next;", + " continue;", + " }", + " used[i] = true;", + " int t = i + 1;", + " dfs_o(e[i].to);", + " path.push_back(t);", + " }", + " }", + "", + "};", + "#define path eu.path", + "", + ] + }, + "Class_Graph_LCA": { + "prefix": "Class_Graph_LCA", + "body": [ + "", + "class LCA {", + " public:", + " int n;", + " vll depth, fa[33];", + "", + " LCA() {}", + " LCA(Graph g, int root) {", + " n = g.n, depth = vll(n + 1, inf);", + " for (int i = 0; i <= 32; i++) fa[i] = vll(n + 1);", + " bfs(g, root);", + " }", + "", + " void bfs(Graph g, int root) {", + " depth[0] = 0, depth[root] = 1;", + " queue q;", + " q.push(root);", + " while (q.size()) {", + " auto u = q.front();", + " q.pop();", + " for (int i = head[u]; ~i; i = e[i].next) {", + " int v = e[i].to;", + " if (depth[v] > depth[u] + 1) {", + " depth[v] = depth[u] + 1;", + " q.push(v);", + " fa[0][v] = u;", + " for (int k = 1; k <= 32; k++) fa[k][v] = fa[k - 1][fa[k - 1][v]];", + " }", + " }", + " }", + " }", + "", + " int query(int a, int b) {", + " if (depth[a] < depth[b]) swap(a, b);", + " for (int i = 32; i >= 0; i--)", + " if (depth[fa[i][a]] >= depth[b]) a = fa[i][a];", + " if (a == b) return a;", + " for (int i = 32; i >= 0; i--)", + " if (fa[i][a] != fa[i][b]) a = fa[i][a], b = fa[i][b];", + " return fa[0][a];", + " }", + "};", + "", + ], + }, + "Class_Graph_erfen": { + "prefix": "Class_Graph_erfen", + "body": [ + "", + "class erfen_graph {", + " public:", + " ll res, n;", + " vi match, st;", + " Graph g;", + " erfen_graph(Graph g) {", + " this->g = g, this->n = g.n;", + " st = vector(n + 1), match = vector(n + 1);", + " res = 0;", + " for (int i = 1; i <= n; i++) {", + " st = vector(n + 1);", + " if (find(i)) res++;", + " }", + " }", + "", + " bool find(int u) {", + " for (int i = head[u]; ~i; i = e[i].next) {", + " if (!st[e[i].to]) {", + " st[e[i].to] = true;", + " if (!match[e[i].to] || find(match[e[i].to])) {", + " match[e[i].to] = u;", + " return true;", + " }", + " }", + " }", + " return false;", + " }", + "};", + "", + ] + } +} \ No newline at end of file diff --git a/snippets/acm/Class_Math.code-snippets b/snippets/acm/Class_Math.code-snippets new file mode 100644 index 0000000..685c88e --- /dev/null +++ b/snippets/acm/Class_Math.code-snippets @@ -0,0 +1,108 @@ +{ + "Math_QuickPow": { + "prefix": "Math_QuickPow", + "body": [ + "", + "ll quick_Pow(ll a, ll b, ll mod) {", + " // a的b次方模mod", + " ll res = 1, t = a;", + " while (b) {", + " if (b & 1) res = (res * t) % mod;", + " t = t * t % mod;", + " b >>= 1;", + " }", + " return res;", + "}", + "", + ], + }, + "Math_Fm": { + "prefix": "Math_Fm", + "body": [ + "", + "ll quick_Pow(ll a, ll b, ll mod) {", + " // a的b次方模mod", + " ll res = 1, t = a;", + " while (b) {", + " if (b & 1) res = (res * t) % mod;", + " t = t * t % mod;", + " b >>= 1;", + " }", + " return res;", + "}", + "", + "ll Fm(ll a, ll mod) {", + " //费马小定理求逆元", + " return quick_Pow(a, mod - 2, mod);", + "}", + "", + ], + }, + "Math_C": { + "prefix": "Math_C", + "body": [ + "", + "ll quick_Pow(ll a, ll b, ll mod) {", + " // a的b次方模mod", + " ll res = 1, t = a;", + " while (b) {", + " if (b & 1) res = (res * t) % mod;", + " t = t * t % mod;", + " b >>= 1;", + " }", + " return res;", + "}", + "", + "ll Fm(ll a, ll mod) {", + " //费马小定理求逆元", + " return quick_Pow(a, mod - 2, mod);", + "}", + "", + "ll C(ll n, ll m, ll mod) {", + " ll fz = 1, fm = 1;", + " for (ll i = n; i >= n - m + 1; i--) fz = fz * i % mod;", + " for (ll i = 1; i <= m; i++) fm = fm * i % mod;", + " return (fz * Fm(fm, mod)) % mod;", + "}", + "", + ], + }, + "Class_Math_Bignum": { + "prefix": "Class_Math_Bignum", + "body": [ + "", + "class Math_Bignum {", + " public:", + " string Bignum;", + "", + " vll num;", + "", + " Math_Bignum(string s) {", + " Bignum = s;", + " for (auto i : s) num.push_back(i - '0');", + " }", + "", + " Math_Bignum(vll v) {", + " string s;", + " num = v;", + " for (auto i : v) s.push_back(i + '0');", + " }", + "", + " Math_Bignum(ll l) {", + " string s;", + " while (l) s.push_back(l % 10 + '0'), num.push_back(l % 10), l /= 10;", + " reverse(num.begin(), num.end());", + " reverse(s.begin(), s.end());", + " Bignum = s;", + " }", + "", + " ll get(ll l, ll r) {", + " ll res = 0;", + " for (int i = l - 1; i <= r - 1; i++) res = res * 10 + num[i];", + " return res;", + " }", + "};", + "", + ], + }, +} \ No newline at end of file