min-heap-typed 1.50.2 → 1.50.4

package/dist/data-structures/binary-tree/tree-multi-map.js

@@ -0,0 +1,399 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeMultiMap = exports.TreeMultiMapNode = void 0;
+const types_1 = require("../../types");
+const rb_tree_1 = require("./rb-tree");
+class TreeMultiMapNode extends rb_tree_1.RedBlackTreeNode {
+    /**
+     * The constructor function initializes an instance of a class with a key, value, and count.
+     * @param {K} key - The key parameter is of type K, which represents the type of the key for the
+     * constructor. It is required and must be provided when creating an instance of the class.
+     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
+     * value associated with the key in the constructor. If no value is provided, it will be `undefined`.
+     * @param [count=1] - The "count" parameter is an optional parameter that specifies the number of
+     * times the key-value pair should be repeated. If no value is provided for "count", it defaults to
+     * 1.
+     */
+    constructor(key, value, count = 1) {
+        super(key, value);
+        this._count = 1;
+        this.count = count;
+    }
+    /**
+     * The function returns the value of the private variable _count.
+     * @returns The count property of the object, which is of type number.
+     */
+    get count() {
+        return this._count;
+    }
+    /**
+     * The above function sets the value of the count property.
+     * @param {number} value - The value parameter is of type number, which means it can accept any
+     * numeric value.
+     */
+    set count(value) {
+        this._count = value;
+    }
+}
+exports.TreeMultiMapNode = TreeMultiMapNode;
+class TreeMultiMap extends rb_tree_1.RedBlackTree {
+    /**
+     * The constructor function initializes a new instance of the TreeMultiMap class with optional
+     * initial keys, nodes, or entries.
+     * @param keysOrNodesOrEntries - The `keysOrNodesOrEntries` parameter is an iterable object that can
+     * contain keys, nodes, or entries. It is used to initialize the TreeMultiMap with the provided keys,
+     * nodes, or entries.
+     * @param [options] - The `options` parameter is an optional object that can be passed to the
+     * constructor. It allows you to customize the behavior of the `TreeMultiMap` instance.
+     */
+    constructor(keysOrNodesOrEntries = [], options) {
+        super([], options);
+        this._count = 0;
+        if (keysOrNodesOrEntries)
+            this.addMany(keysOrNodesOrEntries);
+    }
+    // TODO the _count is not accurate after nodes count modified
+    /**
+     * The function calculates the sum of the count property of all nodes in a tree structure.
+     * @returns the sum of the count property of all nodes in the tree.
+     */
+    get count() {
+        let sum = 0;
+        this.dfs(node => (sum += node.count));
+        return sum;
+        // return this._count;
+    }
+    /**
+     * The function creates a new TreeMultiMapNode object with the specified key, value, and count.
+     * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
+     * which is a generic type that can be replaced with any specific type when using the function.
+     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
+     * associated with the key in the node. It is of type `V`, which can be any data type.
+     * @param {number} [count] - The `count` parameter represents the number of occurrences of a
+     * key-value pair in the TreeMultiMap. It is an optional parameter, so if it is not provided, it will
+     * default to 1.
+     * @returns a new instance of the TreeMultiMapNode class, casted as NODE.
+     */
+    createNode(key, value, count) {
+        return new TreeMultiMapNode(key, value, count);
+    }
+    /**
+     * The function creates a new instance of a TreeMultiMap with the specified options and returns it.
+     * @param [options] - The `options` parameter is an optional object that contains additional
+     * configuration options for creating the `TreeMultiMap`. It can include properties such as
+     * `keyComparator`, `valueComparator`, `allowDuplicates`, etc.
+     * @returns a new instance of the `TreeMultiMap` class, with the provided options merged with the
+     * existing `iterationType` option. The returned value is casted as `TREE`.
+     */
+    createTree(options) {
+        return new TreeMultiMap([], Object.assign({ iterationType: this.iterationType }, options));
+    }
+    /**
+     * The function `keyValueOrEntryToNode` takes a key, value, and count and returns a node if the input
+     * is valid.
+     * @param keyOrNodeOrEntry - The parameter `keyOrNodeOrEntry` can be of type `KeyOrNodeOrEntry<K, V,
+     * NODE>`. It can accept three types of values:
+     * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
+     * value associated with a key in a key-value pair.
+     * @param [count=1] - The count parameter is an optional parameter that specifies the number of times
+     * the key-value pair should be added to the node. If not provided, it defaults to 1.
+     * @returns a NODE object or undefined.
+     */
+    keyValueOrEntryToNode(keyOrNodeOrEntry, value, count = 1) {
+        let node;
+        if (keyOrNodeOrEntry === undefined || keyOrNodeOrEntry === null) {
+            return;
+        }
+        else if (this.isNode(keyOrNodeOrEntry)) {
+            node = keyOrNodeOrEntry;
+        }
+        else if (this.isEntry(keyOrNodeOrEntry)) {
+            const [key, value] = keyOrNodeOrEntry;
+            if (key === undefined || key === null) {
+                return;
+            }
+            else {
+                node = this.createNode(key, value, count);
+            }
+        }
+        else if (!this.isNode(keyOrNodeOrEntry)) {
+            node = this.createNode(keyOrNodeOrEntry, value, count);
+        }
+        else {
+            return;
+        }
+        return node;
+    }
+    /**
+     * The function "isNode" checks if a given key, node, or entry is an instance of the TreeMultiMapNode
+     * class.
+     * @param keyOrNodeOrEntry - The parameter `keyOrNodeOrEntry` can be of type `KeyOrNodeOrEntry<K, V,
+     * NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntry` is an instance
+     * of the `TreeMultiMapNode` class.
+     */
+    isNode(keyOrNodeOrEntry) {
+        return keyOrNodeOrEntry instanceof TreeMultiMapNode;
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The function overrides the add method in TypeScript and adds a new node to the data structure.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can accept three types of values:
+     * @param {V} [value] - The `value` parameter represents the value associated with the key in the
+     * data structure.
+     * @param [count=1] - The `count` parameter represents the number of times the key-value pair should
+     * be added to the data structure. By default, it is set to 1, meaning that the key-value pair will
+     * be added once. However, you can specify a different value for `count` if you want to add
+     * @returns a boolean value.
+     */
+    add(keyOrNodeOrEntry, value, count = 1) {
+        const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value, count);
+        if (newNode === undefined)
+            return false;
+        const orgNodeCount = (newNode === null || newNode === void 0 ? void 0 : newNode.count) || 0;
+        const inserted = super.add(newNode);
+        if (inserted) {
+            this._count += orgNodeCount;
+        }
+        return true;
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The `delete` function in a TypeScript class is used to delete nodes from a binary tree based on a
+     * given identifier, and it returns an array of results containing information about the deleted
+     * nodes.
+     * @param {ReturnType<C> | null | undefined} identifier - The identifier parameter is the value used
+     * to identify the node to be deleted. It can be of any type that is returned by the callback
+     * function. It can also be null or undefined if no node needs to be deleted.
+     * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` as
+     * input and returns a value of type `ReturnType<C>`. It is used to determine if a node matches the
+     * identifier for deletion. If no callback is provided, the `_defaultOneParamCallback` function is
+     * used
+     * @param [ignoreCount=false] - A boolean value indicating whether to ignore the count of the target
+     * node when performing deletion. If set to true, the count of the target node will not be considered
+     * and the node will be deleted regardless of its count. If set to false (default), the count of the
+     * target node will be decremented
+     * @returns an array of BinaryTreeDeleteResult<NODE> objects.
+     */
+    delete(identifier, callback = this._defaultOneParamCallback, ignoreCount = false) {
+        const deleteResults = [];
+        if (identifier === null)
+            return deleteResults;
+        // Helper function to perform deletion
+        const deleteHelper = (node) => {
+            // Initialize targetNode to the sentinel node
+            let targetNode = this._Sentinel;
+            let currentNode;
+            // Find the node to be deleted based on the identifier
+            while (node !== this._Sentinel) {
+                // Update targetNode if the current node matches the identifier
+                if (node && callback(node) === identifier) {
+                    targetNode = node;
+                }
+                // Move to the right or left based on the comparison with the identifier
+                if (node && identifier && callback(node) <= identifier) {
+                    node = node.right;
+                }
+                else {
+                    node = node === null || node === void 0 ? void 0 : node.left;
+                }
+            }
+            // If the target node is not found, decrement size and return
+            if (targetNode === this._Sentinel) {
+                return;
+            }
+            if (ignoreCount || targetNode.count <= 1) {
+                // Store the parent of the target node and its original color
+                let parentNode = targetNode;
+                let parentNodeOriginalColor = parentNode.color;
+                // Handle deletion based on the number of children of the target node
+                if (targetNode.left === this._Sentinel) {
+                    // Target node has no left child - deletion case 1
+                    currentNode = targetNode.right;
+                    this._rbTransplant(targetNode, targetNode.right);
+                }
+                else if (targetNode.right === this._Sentinel) {
+                    // Target node has no right child - deletion case 2
+                    currentNode = targetNode.left;
+                    this._rbTransplant(targetNode, targetNode.left);
+                }
+                else {
+                    // Target node has both left and right children - deletion case 3
+                    parentNode = this.getLeftMost(targetNode.right);
+                    parentNodeOriginalColor = parentNode.color;
+                    currentNode = parentNode.right;
+                    if (parentNode.parent === targetNode) {
+                        // Target node's right child becomes its parent's left child
+                        currentNode.parent = parentNode;
+                    }
+                    else {
+                        // Replace parentNode with its right child and update connections
+                        this._rbTransplant(parentNode, parentNode.right);
+                        parentNode.right = targetNode.right;
+                        parentNode.right.parent = parentNode;
+                    }
+                    // Replace the target node with its in-order successor
+                    this._rbTransplant(targetNode, parentNode);
+                    parentNode.left = targetNode.left;
+                    parentNode.left.parent = parentNode;
+                    parentNode.color = targetNode.color;
+                }
+                // Fix the Red-Black Tree properties after deletion
+                if (parentNodeOriginalColor === types_1.RBTNColor.BLACK) {
+                    this._fixDelete(currentNode);
+                }
+                // Decrement the size and store information about the deleted node
+                this._size--;
+                this._count -= targetNode.count;
+                deleteResults.push({ deleted: targetNode, needBalanced: undefined });
+            }
+            else {
+                targetNode.count--;
+                this._count--;
+            }
+        };
+        // Call the helper function with the root of the tree
+        deleteHelper(this.root);
+        // Return the result array
+        return deleteResults;
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The "clear" function overrides the parent class's "clear" function and also resets the count to
+     * zero.
+     */
+    clear() {
+        super.clear();
+        this._count = 0;
+    }
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(log n)
+     */
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(log n)
+     *
+     * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
+     * tree using either a recursive or iterative approach.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to use when building the balanced binary search tree. It can have two possible
+     * values:
+     * @returns a boolean value.
+     */
+    perfectlyBalance(iterationType = this.iterationType) {
+        const sorted = this.dfs(node => node, 'in'), n = sorted.length;
+        if (sorted.length < 1)
+            return false;
+        this.clear();
+        if (iterationType === types_1.IterationType.RECURSIVE) {
+            const buildBalanceBST = (l, r) => {
+                if (l > r)
+                    return;
+                const m = l + Math.floor((r - l) / 2);
+                const midNode = sorted[m];
+                this.add(midNode.key, midNode.value, midNode.count);
+                buildBalanceBST(l, m - 1);
+                buildBalanceBST(m + 1, r);
+            };
+            buildBalanceBST(0, n - 1);
+            return true;
+        }
+        else {
+            const stack = [[0, n - 1]];
+            while (stack.length > 0) {
+                const popped = stack.pop();
+                if (popped) {
+                    const [l, r] = popped;
+                    if (l <= r) {
+                        const m = l + Math.floor((r - l) / 2);
+                        const midNode = sorted[m];
+                        this.add(midNode.key, midNode.value, midNode.count);
+                        stack.push([m + 1, r]);
+                        stack.push([l, m - 1]);
+                    }
+                }
+            }
+            return true;
+        }
+    }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The function overrides the clone method to create a deep copy of a tree object.
+     * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
+     */
+    clone() {
+        const cloned = this.createTree();
+        this.bfs(node => cloned.add(node.key, node.value, node.count));
+        return cloned;
+    }
+    /**
+     * The function swaps the properties of two nodes in a binary search tree.
+     * @param srcNode - The source node that needs to be swapped with the destination node. It can be
+     * either a key or a node object.
+     * @param destNode - The `destNode` parameter is the node in the binary search tree where the
+     * properties will be swapped with the `srcNode`.
+     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
+     * If both `srcNode` and `destNode` are valid nodes, the method swaps their `key`, `value`, `count`,
+     * and `color` properties. If the swapping is successful, the method returns the modified `destNode`.
+     * If either `srcNode` or `destNode` is
+     */
+    _swapProperties(srcNode, destNode) {
+        srcNode = this.ensureNode(srcNode);
+        destNode = this.ensureNode(destNode);
+        if (srcNode && destNode) {
+            const { key, value, count, color } = destNode;
+            const tempNode = this.createNode(key, value, count);
+            if (tempNode) {
+                tempNode.color = color;
+                destNode.key = srcNode.key;
+                destNode.value = srcNode.value;
+                destNode.count = srcNode.count;
+                destNode.color = srcNode.color;
+                srcNode.key = tempNode.key;
+                srcNode.value = tempNode.value;
+                srcNode.count = tempNode.count;
+                srcNode.color = tempNode.color;
+            }
+            return destNode;
+        }
+        return undefined;
+    }
+    /**
+     * The function replaces an old node with a new node and updates the count property of the new node.
+     * @param {NODE} oldNode - The `oldNode` parameter is of type `NODE` and represents the node that
+     * needs to be replaced in the data structure.
+     * @param {NODE} newNode - The `newNode` parameter is an object of type `NODE`.
+     * @returns The method is returning the result of calling the `_replaceNode` method from the
+     * superclass, after updating the `count` property of the `newNode` object.
+     */
+    _replaceNode(oldNode, newNode) {
+        newNode.count = oldNode.count + newNode.count;
+        return super._replaceNode(oldNode, newNode);
+    }
+}
+exports.TreeMultiMap = TreeMultiMap;

package/dist/data-structures/graph/abstract-graph.d.ts

@@ -362,84 +362,6 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
         costs: number[][];
         predecessor: (VO | undefined)[][];
     };
-    /**
-     * Time Complexity: O(V + E) - Linear time (Tarjan's algorithm).
-     * Space Complexity: O(V) - Linear space (Tarjan's algorithm).
-     * Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
-     * Tarjan can find cycles in directed or undirected graph
-     * Tarjan can find the articulation points and bridges(critical edgeMap) of undirected graphs in linear time,
-     * Tarjan solve the bi-connected components of undirected graphs;
-     * Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
-     * /
-  
-     /**
-     * Time Complexity: O(V + E) - Linear time (Tarjan's algorithm).
-     * Space Complexity: O(V) - Linear space (Tarjan's algorithm).
-     *
-     * Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
-     * Tarjan can find cycles in directed or undirected graph
-     * Tarjan can find the articulation points and bridges(critical edgeMap) of undirected graphs in linear time,
-     * Tarjan solve the bi-connected components of undirected graphs;
-     * Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
-     * The `tarjan` function is used to perform various graph analysis tasks such as finding articulation points, bridges,
-     * strongly connected components (SCCs), and cycles in a graph.
-     * @param {boolean} [needCutVertexes] - A boolean value indicating whether or not to calculate and return the
-     * articulation points in the graph. Articulation points are the vertexMap in a graph whose removal would increase the
-     * number of connected components in the graph.
-     * @param {boolean} [needBridges] - A boolean flag indicating whether the algorithm should find and return the bridges
-     * (edgeMap whose removal would increase the number of connected components in the graph).
-     * @param {boolean} [needSCCs] - A boolean value indicating whether the Strongly Connected Components (SCCs) of the
-     * graph are needed. If set to true, the function will calculate and return the SCCs of the graph. If set to false, the
-     * SCCs will not be calculated or returned.
-     * @param {boolean} [needCycles] - A boolean flag indicating whether the algorithm should find cycles in the graph. If
-     * set to true, the algorithm will return a map of cycles, where the keys are the low values of the SCCs and the values
-     * are arrays of vertexMap that form cycles within the SCCs.
-     * @returns The function `tarjan` returns an object with the following properties:
-     */
-    tarjan(needCutVertexes?: boolean, needBridges?: boolean, needSCCs?: boolean, needCycles?: boolean): {
-        dfnMap: Map<VO, number>;
-        lowMap: Map<VO, number>;
-        bridges: EO[];
-        cutVertexes: VO[];
-        SCCs: Map<number, VO[]>;
-        cycles: Map<number, VO[]>;
-    };
-    /**
-     * Time Complexity: O(V + E) - Depends on the implementation (Tarjan's algorithm).
-     * Space Complexity: O(V) - Depends on the implementation (Tarjan's algorithm).
-     */
-    /**
-     * Time Complexity: O(V + E) - Depends on the implementation (Tarjan's algorithm).
-     * Space Complexity: O(V) - Depends on the implementation (Tarjan's algorithm).
-     *
-     * The function returns a map that associates each vertex object with its corresponding depth-first
-     * number.
-     * @returns A Map object with keys of type VO and values of type number.
-     */
-    getDFNMap(): Map<VO, number>;
-    /**
-     * The function returns a Map object that contains the low values of each vertex in a Tarjan
-     * algorithm.
-     * @returns The method `getLowMap()` is returning a `Map` object with keys of type `VO` and values of
-     * type `number`.
-     */
-    getLowMap(): Map<VO, number>;
-    /**
-     * The function "getCutVertexes" returns an array of cut vertexes using the Tarjan algorithm.
-     * @returns an array of VO objects, specifically the cut vertexes.
-     */
-    getCutVertexes(): VO[];
-    /**
-     * The function "getSCCs" returns a map of strongly connected components (SCCs) using the Tarjan
-     * algorithm.
-     * @returns a map where the keys are numbers and the values are arrays of VO objects.
-     */
-    getSCCs(): Map<number, VO[]>;
-    /**
-     * The function "getBridges" returns an array of bridges using the Tarjan algorithm.
-     * @returns the bridges found using the Tarjan algorithm.
-     */
-    getBridges(): EO[];
     /**
      * O(V+E+C)
      * O(V+C)

package/dist/data-structures/graph/abstract-graph.js

@@ -820,195 +820,6 @@ class AbstractGraph extends base_1.IterableEntryBase {
         }
         return { costs, predecessor };
     }
-    /**
-     * Time Complexity: O(V + E) - Linear time (Tarjan's algorithm).
-     * Space Complexity: O(V) - Linear space (Tarjan's algorithm).
-     * Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
-     * Tarjan can find cycles in directed or undirected graph
-     * Tarjan can find the articulation points and bridges(critical edgeMap) of undirected graphs in linear time,
-     * Tarjan solve the bi-connected components of undirected graphs;
-     * Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
-     * /
-  
-     /**
-     * Time Complexity: O(V + E) - Linear time (Tarjan's algorithm).
-     * Space Complexity: O(V) - Linear space (Tarjan's algorithm).
-     *
-     * Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
-     * Tarjan can find cycles in directed or undirected graph
-     * Tarjan can find the articulation points and bridges(critical edgeMap) of undirected graphs in linear time,
-     * Tarjan solve the bi-connected components of undirected graphs;
-     * Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
-     * The `tarjan` function is used to perform various graph analysis tasks such as finding articulation points, bridges,
-     * strongly connected components (SCCs), and cycles in a graph.
-     * @param {boolean} [needCutVertexes] - A boolean value indicating whether or not to calculate and return the
-     * articulation points in the graph. Articulation points are the vertexMap in a graph whose removal would increase the
-     * number of connected components in the graph.
-     * @param {boolean} [needBridges] - A boolean flag indicating whether the algorithm should find and return the bridges
-     * (edgeMap whose removal would increase the number of connected components in the graph).
-     * @param {boolean} [needSCCs] - A boolean value indicating whether the Strongly Connected Components (SCCs) of the
-     * graph are needed. If set to true, the function will calculate and return the SCCs of the graph. If set to false, the
-     * SCCs will not be calculated or returned.
-     * @param {boolean} [needCycles] - A boolean flag indicating whether the algorithm should find cycles in the graph. If
-     * set to true, the algorithm will return a map of cycles, where the keys are the low values of the SCCs and the values
-     * are arrays of vertexMap that form cycles within the SCCs.
-     * @returns The function `tarjan` returns an object with the following properties:
-     */
-    tarjan(needCutVertexes = false, needBridges = false, needSCCs = true, needCycles = false) {
-        // !! in undirected graph we will not let child visit parent when dfs
-        // !! articulation point(in dfs search tree not in graph): (cur !== root && cur.has(child)) && (low(child) >= dfn(cur)) || (cur === root && cur.children() >= 2)
-        // !! bridge: low(child) > dfn(cur)
-        const defaultConfig = false;
-        if (needCutVertexes === undefined)
-            needCutVertexes = defaultConfig;
-        if (needBridges === undefined)
-            needBridges = defaultConfig;
-        if (needSCCs === undefined)
-            needSCCs = defaultConfig;
-        if (needCycles === undefined)
-            needCycles = defaultConfig;
-        const dfnMap = new Map();
-        const lowMap = new Map();
-        const vertexMap = this._vertexMap;
-        vertexMap.forEach(v => {
-            dfnMap.set(v, -1);
-            lowMap.set(v, Infinity);
-        });
-        const [root] = vertexMap.values();
-        const cutVertexes = [];
-        const bridges = [];
-        let dfn = 0;
-        const dfs = (cur, parent) => {
-            dfn++;
-            dfnMap.set(cur, dfn);
-            lowMap.set(cur, dfn);
-            const neighbors = this.getNeighbors(cur);
-            let childCount = 0; // child in dfs tree not child in graph
-            for (const neighbor of neighbors) {
-                if (neighbor !== parent) {
-                    if (dfnMap.get(neighbor) === -1) {
-                        childCount++;
-                        dfs(neighbor, cur);
-                    }
-                    const childLow = lowMap.get(neighbor);
-                    const curLow = lowMap.get(cur);
-                    // TODO after no-non-undefined-assertion not ensure the logic
-                    if (curLow !== undefined && childLow !== undefined) {
-                        lowMap.set(cur, Math.min(curLow, childLow));
-                    }
-                    const curFromMap = dfnMap.get(cur);
-                    if (childLow !== undefined && curFromMap !== undefined) {
-                        if (needCutVertexes) {
-                            if ((cur === root && childCount >= 2) || (cur !== root && childLow >= curFromMap)) {
-                                // todo not ensure the logic if (cur === root && childCount >= 2 || ((cur !== root) && (childLow >= curFromMap))) {
-                                cutVertexes.push(cur);
-                            }
-                        }
-                        if (needBridges) {
-                            if (childLow > curFromMap) {
-                                const edgeCurToNeighbor = this.getEdge(cur, neighbor);
-                                if (edgeCurToNeighbor) {
-                                    bridges.push(edgeCurToNeighbor);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        };
-        dfs(root, undefined);
-        let SCCs = new Map();
-        const getSCCs = () => {
-            const SCCs = new Map();
-            lowMap.forEach((low, vertex) => {
-                var _a;
-                if (!SCCs.has(low)) {
-                    SCCs.set(low, [vertex]);
-                }
-                else {
-                    (_a = SCCs.get(low)) === null || _a === void 0 ? void 0 : _a.push(vertex);
-                }
-            });
-            return SCCs;
-        };
-        if (needSCCs) {
-            SCCs = getSCCs();
-        }
-        const cycles = new Map();
-        if (needCycles) {
-            const visitedMap = new Map();
-            const stack = [];
-            const findCyclesDFS = (cur, parent) => {
-                visitedMap.set(cur, true);
-                stack.push(cur);
-                const neighbors = this.getNeighbors(cur);
-                for (const neighbor of neighbors) {
-                    if (!visitedMap.get(neighbor)) {
-                        findCyclesDFS(neighbor, cur);
-                    }
-                    else if (stack.includes(neighbor) && neighbor !== parent) {
-                        const cycleStartIndex = stack.indexOf(neighbor);
-                        const cycle = stack.slice(cycleStartIndex);
-                        const cycleLow = Math.min(...cycle.map(v => dfnMap.get(v) || Infinity));
-                        cycles.set(cycleLow, cycle);
-                    }
-                }
-                stack.pop();
-            };
-            vertexMap.forEach(v => {
-                if (!visitedMap.get(v)) {
-                    findCyclesDFS(v, undefined);
-                }
-            });
-        }
-        return { dfnMap, lowMap, bridges, cutVertexes, SCCs, cycles };
-    }
-    /**
-     * Time Complexity: O(V + E) - Depends on the implementation (Tarjan's algorithm).
-     * Space Complexity: O(V) - Depends on the implementation (Tarjan's algorithm).
-     */
-    /**
-     * Time Complexity: O(V + E) - Depends on the implementation (Tarjan's algorithm).
-     * Space Complexity: O(V) - Depends on the implementation (Tarjan's algorithm).
-     *
-     * The function returns a map that associates each vertex object with its corresponding depth-first
-     * number.
-     * @returns A Map object with keys of type VO and values of type number.
-     */
-    getDFNMap() {
-        return this.tarjan(false, false, false, false).dfnMap;
-    }
-    /**
-     * The function returns a Map object that contains the low values of each vertex in a Tarjan
-     * algorithm.
-     * @returns The method `getLowMap()` is returning a `Map` object with keys of type `VO` and values of
-     * type `number`.
-     */
-    getLowMap() {
-        return this.tarjan(false, false, false, false).lowMap;
-    }
-    /**
-     * The function "getCutVertexes" returns an array of cut vertexes using the Tarjan algorithm.
-     * @returns an array of VO objects, specifically the cut vertexes.
-     */
-    getCutVertexes() {
-        return this.tarjan(true, false, false, false).cutVertexes;
-    }
-    /**
-     * The function "getSCCs" returns a map of strongly connected components (SCCs) using the Tarjan
-     * algorithm.
-     * @returns a map where the keys are numbers and the values are arrays of VO objects.
-     */
-    getSCCs() {
-        return this.tarjan(false, false, true, false).SCCs;
-    }
-    /**
-     * The function "getBridges" returns an array of bridges using the Tarjan algorithm.
-     * @returns the bridges found using the Tarjan algorithm.
-     */
-    getBridges() {
-        return this.tarjan(false, true, false, false).bridges;
-    }
     /**
      * O(V+E+C)
      * O(V+C)