From aeb34bff8400e8ec6ddbc5e9f0bef9e6cbfb8fc0 Mon Sep 17 00:00:00 2001 From: arielherself Date: Sat, 2 Dec 2023 12:05:10 +0800 Subject: [PATCH] --- acrobatics/lower_bound_on_custom_iterator.cc | 33 +++++++ graph/hierholzer.cc | 32 +++++++ graph/preorder_inorder_postorder.cc | 47 ++++++++++ {tarjan => graph}/tarjan-cut.cc | 0 {tarjan => graph}/tarjan-scc.cc | 0 trees/BIT.py | 31 +++++++ trees/fhq_treap.cc | 91 ++++++++++++++++++++ {segtree => trees}/segtree-d.cc | 0 {segtree => trees}/segtree.cc | 0 9 files changed, 234 insertions(+) create mode 100644 acrobatics/lower_bound_on_custom_iterator.cc create mode 100644 graph/hierholzer.cc create mode 100644 graph/preorder_inorder_postorder.cc rename {tarjan => graph}/tarjan-cut.cc (100%) rename {tarjan => graph}/tarjan-scc.cc (100%) create mode 100644 trees/BIT.py create mode 100644 trees/fhq_treap.cc rename {segtree => trees}/segtree-d.cc (100%) rename {segtree => trees}/segtree.cc (100%) diff --git a/acrobatics/lower_bound_on_custom_iterator.cc b/acrobatics/lower_bound_on_custom_iterator.cc new file mode 100644 index 0000000..e16045c --- /dev/null +++ b/acrobatics/lower_bound_on_custom_iterator.cc @@ -0,0 +1,33 @@ +#include +using namespace std; + +template class Number { + template friend Number &operator++(Number &); + + public: + using iterator_category = forward_iterator_tag; + using value_type = T; + using difference_type = ptrdiff_t; + using pointer = const T *; + using reference = const T &; + Number(T a) : dat(a) {} + bool operator==(const Number &o) const { return dat == *o; } + bool operator!=(const Number &o) const { return dat != *o; } + const T &operator*() const { return dat; } + Number operator+(ptrdiff_t dt) { return Number(dat + dt); } + + private: + T dat; + void _plusplus() { ++dat; } +}; + +template Number &operator++(Number &it) { + it._plusplus(); + return it; +} + +int main() { + auto cmp = [](int a, int x) { return a <= x; }; + cout << *lower_bound(Number(1), Number(5), 3, cmp); // cout << 3 + 1; + return 0; +} diff --git a/graph/hierholzer.cc b/graph/hierholzer.cc new file mode 100644 index 0000000..a1d6ab1 --- /dev/null +++ b/graph/hierholzer.cc @@ -0,0 +1,32 @@ +/** + * 作者：力扣官方题解 + * 链接：https://leetcode.cn/problems/reconstruct-itinerary/solutions/ + * 来源：力扣（LeetCode） + * 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 + */ + +class Solution { +public: + unordered_map, std::greater>> vec; + + vector stk; + + void dfs(const string& curr) { + while (vec.count(curr) && vec[curr].size() > 0) { + string tmp = vec[curr].top(); + vec[curr].pop(); + dfs(move(tmp)); + } + stk.emplace_back(curr); + } + + vector findItinerary(vector>& tickets) { + for (auto& it : tickets) { + vec[it[0]].emplace(it[1]); + } + dfs("JFK"); + + reverse(stk.begin(), stk.end()); + return stk; + } +}; diff --git a/graph/preorder_inorder_postorder.cc b/graph/preorder_inorder_postorder.cc new file mode 100644 index 0000000..ec57f40 --- /dev/null +++ b/graph/preorder_inorder_postorder.cc @@ -0,0 +1,47 @@ +#include +using namespace std; + +int preorder[1010]; +int inorder[1010]; +int n; + +struct TreeNode { + int val; + TreeNode *lc; + TreeNode *rc; + TreeNode(int v) : val(v) {} + TreeNode(int v, TreeNode *l, TreeNode *r) : val(v), lc(l), rc(r) {} +}; + +TreeNode* dfs(int p_begin, int p_end, int i_begin, int i_end) { + if (i_begin >= i_end) { + return nullptr; + } + auto i_mid = find(inorder + i_begin, inorder + i_end, preorder[p_begin]) - inorder; + int left_sz = i_mid - i_begin; + TreeNode* res = new TreeNode(preorder[p_begin]); + res->lc = dfs(p_begin + 1, p_begin + 1 + left_sz, i_begin, i_mid); + res->rc = dfs(p_begin + 1 + left_sz, p_end, i_mid + 1, i_end); + return res; +} + +void print_postorder(TreeNode *node) { + if (!node) { + return; + } + print_postorder(node->lc); + print_postorder(node->rc); + cout << node->val << ' '; +} + +int main() { + cin >> n; + for (int i = 0; i < n; ++i) { + cin >> preorder[i]; + } + for (int i = 0; i < n; ++i) { + cin >> inorder[i]; + } + print_postorder(dfs(0, n, 0, n)); + return 0; +} diff --git a/tarjan/tarjan-cut.cc b/graph/tarjan-cut.cc similarity index 100% rename from tarjan/tarjan-cut.cc rename to graph/tarjan-cut.cc diff --git a/tarjan/tarjan-scc.cc b/graph/tarjan-scc.cc similarity index 100% rename from tarjan/tarjan-scc.cc rename to graph/tarjan-scc.cc diff --git a/trees/BIT.py b/trees/BIT.py new file mode 100644 index 0000000..9047586 --- /dev/null +++ b/trees/BIT.py @@ -0,0 +1,31 @@ +# @ref https://oi.wiki/ds/fenwick + +n=... +c=[0]*(n+1) + +lowbit=lambda x: x&-x + +def prep(a): + res=[0]*(n+1) + s=0 + for i in range(1,n+1): + s+=a[i] + res[i]=s + return res + +def init(a): + pa=prep(a) + for i in range(1,n+1): + c[i]=pa[i]-pa[i-lowbit(i)] + +def getsum(x): + ans=0 + while x: + ans+=c[x] + x-=lowbit(x) + return ans + +def add(x,k): + while x<=n: + c[x]+=k + x+=lowbit(x) diff --git a/trees/fhq_treap.cc b/trees/fhq_treap.cc new file mode 100644 index 0000000..810074e --- /dev/null +++ b/trees/fhq_treap.cc @@ -0,0 +1,91 @@ +// @link https://www.acwing.com/file_system/file/content/whole/index/content/8807719/ +// Index starts from 1 + +#include +using namespace std; +#define lson fhq[u].l +#define rson fhq[u].r + +const int N = 1e6 + 10; + +struct Node { + int l, r; + int val, key, size; +} fhq[N]; +int cnt, root; + +void pushup(int u) { + fhq[u].size = fhq[lson].size + fhq[rson].size + 1; +} + +int node(int val) { + fhq[++cnt].val = val; + fhq[cnt].key = rand(); + fhq[cnt].size = 1; + return cnt; +} + +void split(int u, int val, int &x, int &y) { + if (!u) x = y = 0; + else { + if (fhq[u].val <= val) x = u, split(rson, val, rson, y); + else y = u, split(lson, val, x, lson); + pushup(u); + } +} + +int merge(int x, int y) { + if (!x || !y) return x + y; + if (fhq[x].key <= fhq[y].key) { + fhq[x].r = merge(fhq[x].r, y); + pushup(x); + return x; + } else { + fhq[y].l = merge(x, fhq[y].l); + pushup(y); + return y; + } +} + +int x, y, z; + +void insert(int val) { + split(root, val, x, y); + root = merge(merge(x, node(val)), y); +} + +void del(int val) { + split(root, val, x, z); + split(x, val - 1, x, y); + y = merge(fhq[y].l, fhq[y].r); + root = merge(merge(x, y), z); +} + +int askRank(int val) { + split(root, val - 1, x, y); + int res = fhq[x].size + 1; + root = merge(x, y); + return res; +} + +int askNum(int u, int rank) { + if (fhq[lson].size + 1 == rank) return fhq[u].val; + if (fhq[lson].size >= rank) return askNum(lson, rank); + else return askNum(rson, rank - fhq[lson].size - 1); +} + +int askPre(int val) { + split(root, val - 1, x, y); + int u = x; + while (rson) u = rson; + root = merge(x, y); + return fhq[u].val; +} + +int askNxt(int val) { + split(root, val, x, y); + int u = y; + while (lson) u = lson; + root = merge(x, y); + return fhq[u].val; +} diff --git a/segtree/segtree-d.cc b/trees/segtree-d.cc similarity index 100% rename from segtree/segtree-d.cc rename to trees/segtree-d.cc diff --git a/segtree/segtree.cc b/trees/segtree.cc similarity index 100% rename from segtree/segtree.cc rename to trees/segtree.cc