min-heap-typed 1.50.2 → 1.50.3

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)

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

@@ -335,12 +335,71 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * @return A boolean value
      */
     isEmpty(): boolean;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The clear function resets the vertex map, in-edge map, and out-edge map.
+     */
+    clear(): void;
     /**
      * The clone function creates a new DirectedGraph object with the same vertices and edges as the original.
      *
      * @return A new instance of the directedgraph class
      */
     clone(): DirectedGraph<V, E, VO, EO>;
+    /**
+     *  Time Complexity: O(V + E)
+     *  Space Complexity: O(V)
+     *  Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
+     *  Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
+     */
+    /**
+     *  Time Complexity: O(V + E)
+     *  Space Complexity: O(V)
+     *  Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
+     *  Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
+     *
+     * The function `tarjan` implements the Tarjan's algorithm to find strongly connected components in a
+     * graph.
+     * @returns The function `tarjan()` returns an object with three properties: `dfnMap`, `lowMap`, and
+     * `SCCs`.
+     */
+    tarjan(): {
+        dfnMap: Map<VO, number>;
+        lowMap: Map<VO, number>;
+        SCCs: 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 "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[]>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -541,6 +541,21 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
     isEmpty() {
         return this.vertexMap.size === 0 && this.inEdgeMap.size === 0 && this.outEdgeMap.size === 0;
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The clear function resets the vertex map, in-edge map, and out-edge map.
+     */
+    clear() {
+        this._vertexMap = new Map();
+        this._inEdgeMap = new Map();
+        this._outEdgeMap = new Map();
+    }
     /**
      * The clone function creates a new DirectedGraph object with the same vertices and edges as the original.
      *
@@ -553,6 +568,96 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
         cloned.outEdgeMap = new Map(this.outEdgeMap);
         return cloned;
     }
+    /**
+     *  Time Complexity: O(V + E)
+     *  Space Complexity: O(V)
+     *  Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
+     *  Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
+     */
+    /**
+     *  Time Complexity: O(V + E)
+     *  Space Complexity: O(V)
+     *  Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
+     *  Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
+     *
+     * The function `tarjan` implements the Tarjan's algorithm to find strongly connected components in a
+     * graph.
+     * @returns The function `tarjan()` returns an object with three properties: `dfnMap`, `lowMap`, and
+     * `SCCs`.
+     */
+    tarjan() {
+        const dfnMap = new Map();
+        const lowMap = new Map();
+        const SCCs = new Map();
+        let time = 0;
+        const stack = [];
+        const inStack = new Set();
+        const dfs = (vertex) => {
+            dfnMap.set(vertex, time);
+            lowMap.set(vertex, time);
+            time++;
+            stack.push(vertex);
+            inStack.add(vertex);
+            const neighbors = this.getNeighbors(vertex);
+            for (const neighbor of neighbors) {
+                if (!dfnMap.has(neighbor)) {
+                    dfs(neighbor);
+                    lowMap.set(vertex, Math.min(lowMap.get(vertex), lowMap.get(neighbor)));
+                }
+                else if (inStack.has(neighbor)) {
+                    lowMap.set(vertex, Math.min(lowMap.get(vertex), dfnMap.get(neighbor)));
+                }
+            }
+            if (dfnMap.get(vertex) === lowMap.get(vertex)) {
+                const SCC = [];
+                let poppedVertex;
+                do {
+                    poppedVertex = stack.pop();
+                    inStack.delete(poppedVertex);
+                    SCC.push(poppedVertex);
+                } while (poppedVertex !== vertex);
+                SCCs.set(SCCs.size, SCC);
+            }
+        };
+        for (const vertex of this.vertexMap.values()) {
+            if (!dfnMap.has(vertex)) {
+                dfs(vertex);
+            }
+        }
+        return { dfnMap, lowMap, SCCs };
+    }
+    /**
+     * 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().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().lowMap;
+    }
+    /**
+     * 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().SCCs;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -19,7 +19,7 @@ export declare class UndirectedVertex<V = any> extends AbstractVertex<V> {
     constructor(key: VertexKey, value?: V);
 }
 export declare class UndirectedEdge<E = number> extends AbstractEdge<E> {
-    vertexMap: [VertexKey, VertexKey];
+    endpoints: [VertexKey, VertexKey];
     /**
      * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
      * value.
@@ -69,7 +69,7 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * Time Complexity: O(|E|), where |E| is the number of edgeMap incident to the given vertex.
      * Space Complexity: O(1)
      *
-     * The function `getEdge` returns the first edge that connects two vertexMap, or undefined if no such edge exists.
+     * The function `getEdge` returns the first edge that connects two endpoints, or undefined if no such edge exists.
      * @param {VO | VertexKey | undefined} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `VO` (vertex
      * object), `undefined`, or `VertexKey` (a string or number representing the ID of a vertex).
      * @param {VO | VertexKey | undefined} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `VO` (vertex
@@ -89,7 +89,7 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * @param {VO | VertexKey} v1 - The parameter `v1` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
      * @param {VO | VertexKey} v2 - VO | VertexKey - This parameter can be either a vertex object (VO) or a vertex ID
      * (VertexKey). It represents the second vertex of the edge that needs to be removed.
-     * @returns the removed edge (EO) if it exists, or undefined if either of the vertexMap (VO) does not exist.
+     * @returns the removed edge (EO) if it exists, or undefined if either of the endpoints (VO) does not exist.
      */
     deleteEdgeBetween(v1: VO | VertexKey, v2: VO | VertexKey): EO | undefined;
     /**
@@ -100,7 +100,7 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * Time Complexity: O(E), where E is the number of edgeMap incident to the given vertex.
      * Space Complexity: O(1)
      *
-     * The function `deleteEdge` deletes an edge between two vertexMap in a graph.
+     * The function `deleteEdge` deletes an edge between two endpoints in a graph.
      * @param {EO | VertexKey} edgeOrOneSideVertexKey - The parameter `edgeOrOneSideVertexKey` can be
      * either an edge object or a vertex key.
      * @param {VertexKey} [otherSideVertexKey] - The parameter `otherSideVertexKey` is an optional
@@ -173,7 +173,7 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * Time Complexity: O(|V| + |E|), where |V| is the number of vertexMap and |E| is the number of edgeMap.
      * Space Complexity: O(|E|)
      *
-     * The function "getNeighbors" returns an array of neighboring vertexMap for a given vertex or vertex ID.
+     * The function "getNeighbors" returns an array of neighboring endpoints for a given vertex or vertex ID.
      * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
      * (`VertexKey`).
      * @returns an array of vertexMap (VO[]).
@@ -187,10 +187,10 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function "getEndsOfEdge" returns the vertexMap at the ends of an edge if the edge exists in the graph, otherwise
+     * The function "getEndsOfEdge" returns the endpoints at the ends of an edge if the edge exists in the graph, otherwise
      * it returns undefined.
      * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
-     * @returns The function `getEndsOfEdge` returns an array containing two vertexMap `[VO, VO]` if the edge exists in the
+     * @returns The function `getEndsOfEdge` returns an array containing two endpoints `[VO, VO]` if the edge exists in the
      * graph. If the edge does not exist, it returns `undefined`.
      */
     getEndsOfEdge(edge: EO): [VO, VO] | undefined;
@@ -199,6 +199,17 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * @return True if the graph is empty and false otherwise
      */
     isEmpty(): boolean;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The clear function resets the vertex and edge maps to empty maps.
+     */
+    clear(): void;
     /**
      * The clone function creates a new UndirectedGraph object and copies the
      * vertexMap and edgeMap from this graph to the new one. This is done by
@@ -213,6 +224,48 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
+    /**
+     *  Time Complexity: O(V + E)
+     *  Space Complexity: O(V)
+     *   Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
+     *  1. Tarjan can find the articulation points and bridges(critical edgeMap) of undirected graphs in linear time
+     *
+     * The function `tarjan` implements the Tarjan's algorithm to find bridges and cut vertices in a
+     * graph.
+     * @returns The function `tarjan()` returns an object with the following properties:
+     */
+    tarjan(): {
+        dfnMap: Map<VO, number>;
+        lowMap: Map<VO, number>;
+        bridges: EO[];
+        cutVertices: VO[];
+    };
+    /**
+     *  Time Complexity: O(V + E)
+     *  Space Complexity: O(V)
+     *  Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
+     *  1. Tarjan can find the articulation points and bridges(critical edgeMap) of undirected graphs in linear time
+     */
+    /**
+     * The function "getBridges" returns an array of bridges in a graph using the Tarjan's algorithm.
+     * @returns The function `getBridges()` is returning the bridges found using the Tarjan's algorithm.
+     */
+    getBridges(): EO[];
+    /**
+     * The function "getCutVertices" returns an array of cut vertices using the Tarjan's algorithm.
+     * @returns the cut vertices found using the Tarjan's algorithm.
+     */
+    getCutVertices(): VO[];
+    /**
+     * The function returns the dfnMap property of the result of the tarjan() function.
+     * @returns the `dfnMap` property of the result of calling the `tarjan()` function.
+     */
+    getDFNMap(): Map<VO, number>;
+    /**
+     * The function returns the lowMap property of the result of the tarjan() function.
+     * @returns the lowMap property of the result of calling the tarjan() function.
+     */
+    getLowMap(): Map<VO, number>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)