min-heap-typed 1.50.2 → 1.50.3

package/src/data-structures/graph/directed-graph.ts

@@ -616,6 +616,23 @@ export class DirectedGraph<
     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<VertexKey, VO>();
+    this._inEdgeMap = new Map<VO, EO[]>();
+    this._outEdgeMap = new Map<VO, EO[]>();
+  }
+
   /**
    * The clone function creates a new DirectedGraph object with the same vertices and edges as the original.
    *
@@ -629,6 +646,111 @@ export class DirectedGraph<
     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(): { dfnMap: Map<VO, number>; lowMap: Map<VO, number>; SCCs: Map<number, VO[]> } {
+    const dfnMap = new Map<VO, number>();
+    const lowMap = new Map<VO, number>();
+    const SCCs = new Map<number, VO[]>();
+
+    let time = 0;
+
+    const stack: VO[] = [];
+    const inStack: Set<VO> = new Set();
+
+    const dfs = (vertex: VO) => {
+      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: VO[] = [];
+        let poppedVertex: VO | undefined;
+
+        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(): Map<VO, number> {
+    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(): Map<VO, number> {
+    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(): Map<number, VO[]> {
+    return this.tarjan().SCCs;
+  }
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)

package/src/data-structures/graph/undirected-graph.ts

@@ -24,7 +24,7 @@ export class UndirectedVertex<V = any> extends AbstractVertex<V> {
 }
 
 export 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
@@ -38,7 +38,7 @@ export class UndirectedEdge<E = number> extends AbstractEdge<E> {
    */
   constructor(v1: VertexKey, v2: VertexKey, weight?: number, value?: E) {
     super(weight, value);
-    this.vertexMap = [v1, v2];
+    this.endpoints = [v1, v2];
   }
 }
 
@@ -104,7 +104,7 @@ export class UndirectedGraph<
    * 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
@@ -119,7 +119,7 @@ export class UndirectedGraph<
       const vertex2: VO | undefined = this._getVertex(v2);
 
       if (vertex1 && vertex2) {
-        edgeMap = this._edgeMap.get(vertex1)?.filter(e => e.vertexMap.includes(vertex2.key));
+        edgeMap = this._edgeMap.get(vertex1)?.filter(e => e.endpoints.includes(vertex2.key));
       }
     }
 
@@ -139,7 +139,7 @@ export class UndirectedGraph<
    * @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 {
     const vertex1: VO | undefined = this._getVertex(v1);
@@ -152,11 +152,11 @@ export class UndirectedGraph<
     const v1Edges = this._edgeMap.get(vertex1);
     let removed: EO | undefined = undefined;
     if (v1Edges) {
-      removed = arrayRemove<EO>(v1Edges, (e: EO) => e.vertexMap.includes(vertex2.key))[0] || undefined;
+      removed = arrayRemove<EO>(v1Edges, (e: EO) => e.endpoints.includes(vertex2.key))[0] || undefined;
     }
     const v2Edges = this._edgeMap.get(vertex2);
     if (v2Edges) {
-      arrayRemove<EO>(v2Edges, (e: EO) => e.vertexMap.includes(vertex1.key));
+      arrayRemove<EO>(v2Edges, (e: EO) => e.endpoints.includes(vertex1.key));
     }
     return removed;
   }
@@ -170,7 +170,7 @@ export class UndirectedGraph<
    * 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
@@ -189,8 +189,8 @@ export class UndirectedGraph<
         return;
       }
     } else {
-      oneSide = this._getVertex(edgeOrOneSideVertexKey.vertexMap[0]);
-      otherSide = this._getVertex(edgeOrOneSideVertexKey.vertexMap[1]);
+      oneSide = this._getVertex(edgeOrOneSideVertexKey.endpoints[0]);
+      otherSide = this._getVertex(edgeOrOneSideVertexKey.endpoints[1]);
     }
 
     if (oneSide && otherSide) {
@@ -232,7 +232,7 @@ export class UndirectedGraph<
         const neighborEdges = this._edgeMap.get(neighbor);
         if (neighborEdges) {
           const restEdges = neighborEdges.filter(edge => {
-            return !edge.vertexMap.includes(vertexKey);
+            return !edge.endpoints.includes(vertexKey);
           });
           this._edgeMap.set(neighbor, restEdges);
         }
@@ -321,7 +321,7 @@ export class UndirectedGraph<
    * 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[]).
@@ -332,7 +332,7 @@ export class UndirectedGraph<
     if (vertex) {
       const neighborEdges = this.edgesOf(vertex);
       for (const edge of neighborEdges) {
-        const neighbor = this._getVertex(edge.vertexMap.filter(e => e !== vertex.key)[0]);
+        const neighbor = this._getVertex(edge.endpoints.filter(e => e !== vertex.key)[0]);
         if (neighbor) {
           neighbors.push(neighbor);
         }
@@ -350,18 +350,18 @@ export class UndirectedGraph<
    * 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 {
-    if (!this.hasEdge(edge.vertexMap[0], edge.vertexMap[1])) {
+    if (!this.hasEdge(edge.endpoints[0], edge.endpoints[1])) {
       return undefined;
     }
-    const v1 = this._getVertex(edge.vertexMap[0]);
-    const v2 = this._getVertex(edge.vertexMap[1]);
+    const v1 = this._getVertex(edge.endpoints[0]);
+    const v2 = this._getVertex(edge.endpoints[1]);
     if (v1 && v2) {
       return [v1, v2];
     } else {
@@ -377,6 +377,22 @@ export class UndirectedGraph<
     return this.vertexMap.size === 0 && this.edgeMap.size === 0;
   }
 
+  /**
+   * 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() {
+    this._vertexMap = new Map<VertexKey, VO>();
+    this._edgeMap = new Map<VO, EO[]>();
+  }
+
   /**
    * 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
@@ -398,6 +414,114 @@ export class UndirectedGraph<
    * 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[] } {
+    const dfnMap = new Map<VO, number>();
+    const lowMap = new Map<VO, number>();
+    const bridges: EO[] = [];
+    const cutVertices: VO[] = [];
+
+    let time = 0;
+
+    const dfs = (vertex: VO, parent: VO | undefined) => {
+      dfnMap.set(vertex, time);
+      lowMap.set(vertex, time);
+      time++;
+
+      const neighbors = this.getNeighbors(vertex);
+      let childCount = 0;
+
+      for (const neighbor of neighbors) {
+        if (!dfnMap.has(neighbor)) {
+          childCount++;
+          dfs(neighbor, vertex);
+          lowMap.set(vertex, Math.min(lowMap.get(vertex)!, lowMap.get(neighbor)!));
+
+          if (lowMap.get(neighbor)! > dfnMap.get(vertex)!) {
+            // Found a bridge
+            const edge = this.getEdge(vertex, neighbor);
+            if (edge) {
+              bridges.push(edge);
+            }
+          }
+
+          if (parent !== undefined && lowMap.get(neighbor)! >= dfnMap.get(vertex)!) {
+            // Found an articulation point
+            cutVertices.push(vertex);
+          }
+        } else if (neighbor !== parent) {
+          lowMap.set(vertex, Math.min(lowMap.get(vertex)!, dfnMap.get(neighbor)!));
+        }
+      }
+
+      if (parent === undefined && childCount > 1) {
+        // Special case for root in DFS tree
+        cutVertices.push(vertex);
+      }
+    };
+
+    for (const vertex of this.vertexMap.values()) {
+      if (!dfnMap.has(vertex)) {
+        dfs(vertex, undefined);
+      }
+    }
+
+    return {
+      dfnMap,
+      lowMap,
+      bridges,
+      cutVertices
+    };
+  }
+
+  /**
+   *  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() {
+    return this.tarjan().bridges;
+  }
+
+  /**
+   * 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() {
+    return this.tarjan().cutVertices;
+  }
+
+  /**
+   * 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() {
+    return this.tarjan().dfnMap;
+  }
+
+  /**
+   * 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() {
+    return this.tarjan().lowMap;
+  }
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -407,7 +531,7 @@ export class UndirectedGraph<
    * @returns a boolean value.
    */
   protected _addEdge(edge: EO): boolean {
-    for (const end of edge.vertexMap) {
+    for (const end of edge.endpoints) {
       const endVertex = this._getVertex(end);
       if (endVertex === undefined) return false;
       if (endVertex) {