Add Pseudocode

Author: GauthamBanasandra

Pseudocode/Graph/12-June-2025/segment-tree.txt

@@ -34,7 +34,7 @@ int rmq(p, L, R, i, j) {
     if (i > R || j < L) {
         return -1
     }
-    if (L >= i && R >= j) {
+    if (L >= i && R <= j) {
         return st[p]
     }
 

Pseudocode/Graph/13-June-2025/segment-tree.txt

@@ -0,0 +1,57 @@
+class SegmentTree {
+    SegmentTree(vector<int> nums)
+    int rmq(i, j)
+
+    int left(p) { return p << 1 }
+    int right(p) { return (p << 1) + 1 }
+    void build(p, L, R)
+    int rmq(p, L, R, i, j)
+
+    int n
+    vector<int> nums, st
+}
+
+SegmentTree(vector<int> nums) : nums(nums), n(nums.size()) {
+    st.resize(n)
+    build(1, 0, n - 1)
+}
+
+void build(p, L, R) {
+    if (L == R) {
+        st[p] = L
+    } else {
+        build(left(p), L, (L + R) / 2)
+        build(right(p), (L + R) / 2 + 1, R)
+
+        p1 = st[left(p)]
+        p2 = st[right(p)]
+
+        st[p] = (nums[p1] <= nums[p2]) ? p1 : p2
+    }
+}
+
+int rmq(p, L, R, i, j) {
+    if (i > R || j < L) {
+        return -1
+    }
+
+    if (L >= i && R <= j) {
+        return st[p]
+    }
+
+    p1 = rmq(left(p), L, (L + R) / 2, i, j)
+    p2 = rmq(right(p), (L + R) / 2 + 1, R, i, j)
+
+    if (p1 == -1) {
+        return p2
+    }
+    if (p2 == -1) {
+        return p1
+    }
+
+    return (nums[p1] < nums[p2]) ? p1 : p2
+}
+
+int rmq(i, j) {
+    return rmq(1, 0, n - 1, i, j)
+}

Pseudocode/Graph/16-June-2025/dijkstra.txt

@@ -0,0 +1,32 @@
+using Node = int
+using Weight = int
+using AdjList = unordered_map<Node, vector<pair<Node, Weight>>>
+
+Node src, dst
+AdjList adj_list
+unordered_map<Node, Weight> min_dist
+
+// Init all Node to inf
+
+priority_queue<pair<Weight, Node>, vector<pair<Weight, Node>>, greater<>> order
+
+min_dist[src] = 0
+order.emplace(0, src)
+
+while (!order.empty()) {
+    [du, u] = order.top()
+    order.pop()
+
+    if (du > min_dist[u]) {
+        continue
+    }
+
+    for ([v, dv] : adj_list[u]) {
+        if (min_dist[u] + dv < min_dist[v]) {
+            min_dist[v] = min_dist[u] + dv
+            order.emplace(min_dist[v], v)
+        }
+    }
+}
+
+return min_dist[dst]

Pseudocode/Graph/16-June-2025/kruskal.txt

@@ -0,0 +1,66 @@
+class UFDS {
+public:
+    UFDS(int num_v)
+    int FindParent(u)
+    bool IsSameSet(u, v)
+    void Union(u, v)
+
+private:
+    int num_v
+    vector<int> parent
+    vector<int> rank
+}
+
+UFDS(int num_v) : num_v(num_v) {
+    parent.resize(num_v)
+    rank.resize(num_v)
+    iota(parent.begin(), parent.end(), 0)
+}
+
+int FindParent(u) {
+    if (parent[u] == u) {
+        return u
+    }
+
+    return parent[u] = u
+}
+
+bool IsSameSet(u, v) {
+    return FindParent(u) == FindParent(v)
+}
+
+void Union(u, v) {
+    if (!IsSameSet(u, v)) {
+        pu = FindParent(u)
+        pv = FindParent(v)
+
+        if (rank[pu] > rank[pv]) {
+            parent[v] = pu
+        } else {
+            parent[u] = pv
+            if (rank[pu] == rank[pv]) {
+                ++rank[pv]
+            }
+        }
+    }
+}
+
+using Node = int
+using Weight = int
+using Edge = pair<Node, Node>
+
+vector<pair<Weight, Edge>> edge_list
+UFDS ufds(num_v)
+
+ranges::sort(edge_list)
+
+cost = 0
+for ([w, edge] : edge_list) {
+    [u, v] = edge
+    if (!ufds.IsSameSet(u, v)) {
+        ufds.Union(u, v)
+        cost += w
+    }
+}
+
+return cost

Pseudocode/Graph/16-June-2025/segment-tree.txt

@@ -0,0 +1,58 @@
+class SegmentTree {
+public:
+    SegmentTree(vector<int> nums)
+    int rmq(i, j)
+
+private:
+    int left(p) { return p << 1 }
+    int right(p) { return (p << 1) + 1 }
+    void build(p, L, R)
+    int rmq(p, L, R, i, j)
+
+    int n
+    vector<int> nums
+    vector<int> st
+}
+
+SegmentTree(vector<int> nums) : nums(nums), n(nums.size()) {
+    st.resize(n)
+    build(1, 0, n - 1)
+}
+
+void build(p, L, R) {
+    if (L == R) {
+        st[p] = L
+    } else {
+        build(left(p), L, (L + R) / 2)
+        build(right(p), (L + R) / 2 + 1, R)
+
+        p1 = st[left(p)]
+        p2 = st[right(p)]
+        st[p] = nums[p1] <= nums[p2] ? p1 : p2
+    }
+}
+
+int rmq(p, L, R, i, j) {
+    if (i > R || j < L) {
+        return -1
+    }
+    if (L >= i && R <= j) {
+        return st[p]
+    }
+
+    p1 = rmq(left(p), L, (L + R) / 2, i, j)
+    p2 = rmq(right(p), (L + R) / 2 + 1, R, i, j)
+
+    if (p1 == -1) {
+        return p2
+    }
+    if (p2 == -1) {
+        return p1
+    }
+
+    return nums[p1] <= nums[p2] ? p1 : p2
+}
+
+int rmq(i, j) {
+    return rmq(1, 0, n - 1, i, j)
+}