data-structure-typed 0.9.16 → 1.12.9

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

@@ -1,7 +1,7 @@
 import type { DijkstraResult, IGraph, VertexId } from '../types';
 export declare class AbstractVertex {
     constructor(id: VertexId);
-    private _id;
+    protected _id: VertexId;
     get id(): VertexId;
     set id(v: VertexId);
 }
@@ -19,49 +19,179 @@ export declare abstract class AbstractGraph<V extends AbstractVertex, E extends
     protected _vertices: Map<VertexId, V>;
     abstract removeEdgeBetween(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
     abstract removeEdge(edge: E): E | null;
+    /**
+     * The function `getVertex` returns the vertex object associated with a given vertex ID or vertex object, or null if it
+     * does not exist.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @returns The function `getVertex` returns the vertex object (`V`) corresponding to the given `vertexOrId` parameter.
+     * If the vertex is found in the `_vertices` map, it is returned. Otherwise, `null` is returned.
+     */
     getVertex(vertexOrId: VertexId | V): V | null;
+    /**
+     * The function `getVertexId` returns the id of a vertex, whether it is passed as an instance of `AbstractVertex` or as
+     * a `VertexId`.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns the id of the vertex.
+     */
     getVertexId(vertexOrId: V | VertexId): VertexId;
+    /**
+     * The function checks if a vertex exists in a graph.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can accept either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns The method `containsVertex` returns a boolean value.
+     */
     containsVertex(vertexOrId: V | VertexId): boolean;
+    /**
+     * The function `vertexSet()` returns a map of vertices.
+     * @returns The method `vertexSet()` returns a map of vertex IDs to vertex objects.
+     */
     vertexSet(): Map<VertexId, V>;
     abstract getEdge(srcOrId: V | null | VertexId, destOrId: V | null | VertexId): E | null;
+    /**
+     * The addVertex function adds a new vertex to a graph if it does not already exist.
+     * @param {V} newVertex - The parameter "newVertex" is of type V, which represents a vertex in a graph.
+     * @returns The method is returning a boolean value. If the newVertex is already contained in the graph, it will return
+     * false. Otherwise, it will add the newVertex to the graph and return true.
+     */
     addVertex(newVertex: V): boolean;
+    /**
+     * The `removeVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns The method `removeVertex` returns a boolean value.
+     */
     removeVertex(vertexOrId: V | VertexId): boolean;
+    /**
+     * The function removes all vertices from a graph and returns a boolean indicating if any vertices were removed.
+     * @param {V[] | VertexId[]} vertices - The `vertices` parameter can be either an array of vertices (`V[]`) or an array
+     * of vertex IDs (`VertexId[]`).
+     * @returns a boolean value. It returns true if at least one vertex was successfully removed, and false if no vertices
+     * were removed.
+     */
     removeAllVertices(vertices: V[] | VertexId[]): boolean;
     abstract degreeOf(vertexOrId: V | VertexId): number;
     abstract edgeSet(): E[];
     abstract edgesOf(vertexOrId: V | VertexId): E[];
+    /**
+     * The function checks if there is an edge between two vertices in a graph.
+     * @param {VertexId | V} v1 - The parameter v1 can be either a VertexId or a V. A VertexId represents the identifier of
+     * a vertex in a graph, while V represents the type of the vertex itself.
+     * @param {VertexId | V} v2 - The parameter `v2` represents the second vertex in an edge. It can be either a `VertexId`
+     * or a `V` type.
+     * @returns The function `containsEdge` returns a boolean value. It returns `true` if there is an edge between the
+     * vertices `v1` and `v2`, and `false` otherwise.
+     */
     containsEdge(v1: VertexId | V, v2: VertexId | V): boolean;
     abstract addEdge(edge: E): boolean;
+    /**
+     * The function sets the weight of an edge between two vertices in a graph.
+     * @param {VertexId | V} srcOrId - The `srcOrId` parameter can be either a `VertexId` or a `V` object. It represents
+     * the source vertex of the edge.
+     * @param {VertexId | V} destOrId - The `destOrId` parameter represents the destination vertex of the edge. It can be
+     * either a `VertexId` or a vertex object `V`.
+     * @param {number} weight - The weight parameter represents the weight of the edge between the source vertex (srcOrId)
+     * and the destination vertex (destOrId).
+     * @returns a boolean value. If the edge exists between the source and destination vertices, the function will update
+     * the weight of the edge and return true. If the edge does not exist, the function will return false.
+     */
     setEdgeWeight(srcOrId: VertexId | V, destOrId: VertexId | V, weight: number): boolean;
     abstract getNeighbors(vertexOrId: V | VertexId): V[];
+    /**
+     * The function `getAllPathsBetween` finds all paths between two vertices in a graph using depth-first search.
+     * @param {V | VertexId} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID (`VertexId`).
+     * It is the starting vertex for finding paths.
+     * @param {V | VertexId} v2 - The parameter `v2` represents the destination vertex or its ID. It is the vertex that we
+     * want to find paths to from the starting vertex `v1`.
+     * @returns an array of arrays of vertices (V[][]). Each inner array represents a path between the given vertices (v1
+     * and v2).
+     */
     getAllPathsBetween(v1: V | VertexId, v2: V | VertexId): V[][];
+    /**
+     * The function calculates the sum of weights along a given path.
+     * @param {V[]} path - An array of vertices (V) representing a path in a graph.
+     * @returns The function `getPathSumWeight` returns the sum of the weights of the edges in the given path.
+     */
     getPathSumWeight(path: V[]): number;
+    /**
+     * The function `getMinCostBetween` calculates the minimum cost between two vertices in a graph, either based on edge
+     * weights or using a breadth-first search algorithm.
+     * @param {V | VertexId} v1 - The parameter `v1` represents the starting vertex or vertex ID of the graph.
+     * @param {V | VertexId} v2 - The parameter `v2` represents the second vertex in the graph. It can be either a vertex
+     * object or a vertex ID.
+     * @param {boolean} [isWeight] - isWeight is an optional parameter that indicates whether the graph edges have weights.
+     * If isWeight is set to true, the function will calculate the minimum cost between v1 and v2 based on the weights of
+     * the edges. If isWeight is set to false or not provided, the function will calculate the
+     * @returns The function `getMinCostBetween` returns a number representing the minimum cost between two vertices (`v1`
+     * and `v2`) in a graph. If the `isWeight` parameter is `true`, it calculates the minimum weight between the vertices.
+     * If `isWeight` is `false` or not provided, it calculates the minimum number of edges between the vertices. If the
+     * vertices are not
+     */
     getMinCostBetween(v1: V | VertexId, v2: V | VertexId, isWeight?: boolean): number | null;
+    /**
+     * The function `getMinPathBetween` returns the minimum path between two vertices in a graph, either based on weight or
+     * using a breadth-first search algorithm.
+     * @param {V | VertexId} v1 - The parameter `v1` represents the starting vertex or its ID.
+     * @param {V | VertexId} v2 - The parameter `v2` represents the destination vertex or its ID. It is the vertex that we
+     * want to find the minimum path to from the source vertex `v1`.
+     * @param {boolean} [isWeight] - A boolean flag indicating whether to consider the weight of edges in finding the
+     * minimum path. If set to true, the function will use Dijkstra's algorithm to find the minimum weighted path. If set
+     * to false, the function will use breadth-first search (BFS) to find the minimum path. If
+     * @returns The function `getMinPathBetween` returns an array of vertices (`V[]`) representing the minimum path between
+     * two vertices (`v1` and `v2`). If no path is found, it returns `null`.
+     */
     getMinPathBetween(v1: V | VertexId, v2: V | VertexId, isWeight?: boolean): V[] | null;
     /**
      * Dijkstra algorithm time: O(VE) space: O(V + E)
-     * @param src
-     * @param dest
-     * @param getMinDist
-     * @param genPaths
+     * The function `dijkstraWithoutHeap` implements Dijkstra's algorithm to find the shortest path between two vertices in
+     * a graph without using a heap data structure.
+     * @param {V | VertexId} src - The source vertex from which to start the Dijkstra's algorithm. It can be either a
+     * vertex object or a vertex ID.
+     * @param {V | VertexId | null} [dest] - The `dest` parameter in the `dijkstraWithoutHeap` function is an optional
+     * parameter that specifies the destination vertex for the Dijkstra algorithm. It can be either a vertex object or its
+     * identifier. If no destination is provided, the value is set to `null`.
+     * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
+     * distance from the source vertex to the destination vertex should be calculated and returned in the result. If
+     * `getMinDist` is set to `true`, the `minDist` property in the result will contain the minimum distance
+     * @param {boolean} [genPaths] - The `genPaths` parameter is a boolean flag that determines whether or not to generate
+     * paths in the Dijkstra algorithm. If `genPaths` is set to `true`, the algorithm will calculate and return the
+     * shortest paths from the source vertex to all other vertices in the graph. If `genPaths
+     * @returns The function `dijkstraWithoutHeap` returns an object of type `DijkstraResult<V>`.
      */
     dijkstraWithoutHeap(src: V | VertexId, dest?: V | VertexId | null, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<V>;
     /**
      * Dijkstra algorithm time: O(logVE) space: O(V + E)
-     * @param src
-     * @param dest
-     * @param getMinDist
-     * @param genPaths
+     * The `dijkstra` function implements Dijkstra's algorithm to find the shortest path between a source vertex and an
+     * optional destination vertex, and optionally returns the minimum distance, the paths, and other information.
+     * @param {V | VertexId} src - The `src` parameter represents the source vertex from which the Dijkstra algorithm will
+     * start. It can be either a vertex object or a vertex ID.
+     * @param {V | VertexId | null} [dest] - The `dest` parameter is the destination vertex or vertex ID. It specifies the
+     * vertex to which the shortest path is calculated from the source vertex. If no destination is provided, the algorithm
+     * will calculate the shortest paths to all other vertices from the source vertex.
+     * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
+     * distance from the source vertex to the destination vertex should be calculated and returned in the result. If
+     * `getMinDist` is set to `true`, the `minDist` property in the result will contain the minimum distance
+     * @param {boolean} [genPaths] - The `genPaths` parameter is a boolean flag that determines whether or not to generate
+     * paths in the Dijkstra algorithm. If `genPaths` is set to `true`, the algorithm will calculate and return the
+     * shortest paths from the source vertex to all other vertices in the graph. If `genPaths
+     * @returns The function `dijkstra` returns an object of type `DijkstraResult<V>`.
      */
     dijkstra(src: V | VertexId, dest?: V | VertexId | null, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<V>;
     abstract getEndsOfEdge(edge: E): [V, V] | null;
     /**
      * BellmanFord time:O(VE) space:O(V)
      * one to rest pairs
-     * @param src
-     * @param scanNegativeCycle
-     * @param getMin
-     * @param genPath
+     * The `bellmanFord` function implements the Bellman-Ford algorithm to find the shortest path from a source vertex to
+     * all other vertices in a graph, and optionally detects negative cycles and generates the minimum path.
+     * @param {V | VertexId} src - The `src` parameter is the source vertex from which the Bellman-Ford algorithm will
+     * start calculating the shortest paths. It can be either a vertex object or a vertex ID.
+     * @param {boolean} [scanNegativeCycle] - A boolean flag indicating whether to scan for negative cycles in the graph.
+     * @param {boolean} [getMin] - The `getMin` parameter is a boolean flag that determines whether the algorithm should
+     * calculate the minimum distance from the source vertex to all other vertices in the graph. If `getMin` is set to
+     * `true`, the algorithm will find the minimum distance and update the `min` variable with the minimum
+     * @param {boolean} [genPath] - A boolean flag indicating whether to generate paths for all vertices from the source
+     * vertex.
+     * @returns The function `bellmanFord` returns an object with the following properties:
      */
     bellmanFord(src: V | VertexId, scanNegativeCycle?: boolean, getMin?: boolean, genPath?: boolean): {
         hasNegativeCycle: boolean | undefined;
@@ -74,6 +204,12 @@ export declare abstract class AbstractGraph<V extends AbstractVertex, E extends
     /**
      * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
      * all pairs
+     * The function implements the Floyd-Warshall algorithm to find the shortest path between all pairs of vertices in a
+     * graph.
+     * @returns The function `floyd()` returns an object with two properties: `costs` and `predecessor`. The `costs`
+     * property is a 2D array of numbers representing the shortest path costs between vertices in a graph. The
+     * `predecessor` property is a 2D array of vertices (or `null`) representing the predecessor vertices in the shortest
+     * path between vertices in the
      */
     floyd(): {
         costs: number[][];
@@ -86,6 +222,20 @@ export declare abstract class AbstractGraph<V extends AbstractVertex, E extends
      * Tarjan can find the articulation points and bridges(critical edges) 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} [needArticulationPoints] - A boolean value indicating whether or not to calculate and return the
+     * articulation points in the graph. Articulation points are the vertices 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
+     * (edges 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 vertices that form cycles within the SCCs.
+     * @returns The function `tarjan` returns an object with the following properties:
      */
     tarjan(needArticulationPoints?: boolean, needBridges?: boolean, needSCCs?: boolean, needCycles?: boolean): {
         dfnMap: Map<V, number>;

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

@@ -37,6 +37,10 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractGraph = exports.AbstractEdge = exports.AbstractVertex = void 0;
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 var utils_1 = require("../../utils");
 var priority_queue_1 = require("../priority-queue");
 var AbstractVertex = /** @class */ (function () {
@@ -96,19 +100,49 @@ var AbstractGraph = /** @class */ (function () {
         /**--- end find cycles --- */
         // Minimum Spanning Tree
     }
+    /**
+     * The function `getVertex` returns the vertex object associated with a given vertex ID or vertex object, or null if it
+     * does not exist.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @returns The function `getVertex` returns the vertex object (`V`) corresponding to the given `vertexOrId` parameter.
+     * If the vertex is found in the `_vertices` map, it is returned. Otherwise, `null` is returned.
+     */
     AbstractGraph.prototype.getVertex = function (vertexOrId) {
         var vertexId = this.getVertexId(vertexOrId);
         return this._vertices.get(vertexId) || null;
     };
+    /**
+     * The function `getVertexId` returns the id of a vertex, whether it is passed as an instance of `AbstractVertex` or as
+     * a `VertexId`.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns the id of the vertex.
+     */
     AbstractGraph.prototype.getVertexId = function (vertexOrId) {
         return vertexOrId instanceof AbstractVertex ? vertexOrId.id : vertexOrId;
     };
+    /**
+     * The function checks if a vertex exists in a graph.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can accept either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns The method `containsVertex` returns a boolean value.
+     */
     AbstractGraph.prototype.containsVertex = function (vertexOrId) {
         return this._vertices.has(this.getVertexId(vertexOrId));
     };
+    /**
+     * The function `vertexSet()` returns a map of vertices.
+     * @returns The method `vertexSet()` returns a map of vertex IDs to vertex objects.
+     */
     AbstractGraph.prototype.vertexSet = function () {
         return this._vertices;
     };
+    /**
+     * The addVertex function adds a new vertex to a graph if it does not already exist.
+     * @param {V} newVertex - The parameter "newVertex" is of type V, which represents a vertex in a graph.
+     * @returns The method is returning a boolean value. If the newVertex is already contained in the graph, it will return
+     * false. Otherwise, it will add the newVertex to the graph and return true.
+     */
     AbstractGraph.prototype.addVertex = function (newVertex) {
         if (this.containsVertex(newVertex)) {
             return false;
@@ -116,10 +150,23 @@ var AbstractGraph = /** @class */ (function () {
         this._vertices.set(newVertex.id, newVertex);
         return true;
     };
+    /**
+     * The `removeVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns The method `removeVertex` returns a boolean value.
+     */
     AbstractGraph.prototype.removeVertex = function (vertexOrId) {
         var vertexId = this.getVertexId(vertexOrId);
         return this._vertices.delete(vertexId);
     };
+    /**
+     * The function removes all vertices from a graph and returns a boolean indicating if any vertices were removed.
+     * @param {V[] | VertexId[]} vertices - The `vertices` parameter can be either an array of vertices (`V[]`) or an array
+     * of vertex IDs (`VertexId[]`).
+     * @returns a boolean value. It returns true if at least one vertex was successfully removed, and false if no vertices
+     * were removed.
+     */
     AbstractGraph.prototype.removeAllVertices = function (vertices) {
         var e_1, _a;
         var removed = [];
@@ -138,10 +185,30 @@ var AbstractGraph = /** @class */ (function () {
         }
         return removed.length > 0;
     };
+    /**
+     * The function checks if there is an edge between two vertices in a graph.
+     * @param {VertexId | V} v1 - The parameter v1 can be either a VertexId or a V. A VertexId represents the identifier of
+     * a vertex in a graph, while V represents the type of the vertex itself.
+     * @param {VertexId | V} v2 - The parameter `v2` represents the second vertex in an edge. It can be either a `VertexId`
+     * or a `V` type.
+     * @returns The function `containsEdge` returns a boolean value. It returns `true` if there is an edge between the
+     * vertices `v1` and `v2`, and `false` otherwise.
+     */
     AbstractGraph.prototype.containsEdge = function (v1, v2) {
         var edge = this.getEdge(v1, v2);
         return !!edge;
     };
+    /**
+     * The function sets the weight of an edge between two vertices in a graph.
+     * @param {VertexId | V} srcOrId - The `srcOrId` parameter can be either a `VertexId` or a `V` object. It represents
+     * the source vertex of the edge.
+     * @param {VertexId | V} destOrId - The `destOrId` parameter represents the destination vertex of the edge. It can be
+     * either a `VertexId` or a vertex object `V`.
+     * @param {number} weight - The weight parameter represents the weight of the edge between the source vertex (srcOrId)
+     * and the destination vertex (destOrId).
+     * @returns a boolean value. If the edge exists between the source and destination vertices, the function will update
+     * the weight of the edge and return true. If the edge does not exist, the function will return false.
+     */
     AbstractGraph.prototype.setEdgeWeight = function (srcOrId, destOrId, weight) {
         var edge = this.getEdge(srcOrId, destOrId);
         if (edge) {
@@ -152,6 +219,15 @@ var AbstractGraph = /** @class */ (function () {
             return false;
         }
     };
+    /**
+     * The function `getAllPathsBetween` finds all paths between two vertices in a graph using depth-first search.
+     * @param {V | VertexId} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID (`VertexId`).
+     * It is the starting vertex for finding paths.
+     * @param {V | VertexId} v2 - The parameter `v2` represents the destination vertex or its ID. It is the vertex that we
+     * want to find paths to from the starting vertex `v1`.
+     * @returns an array of arrays of vertices (V[][]). Each inner array represents a path between the given vertices (v1
+     * and v2).
+     */
     AbstractGraph.prototype.getAllPathsBetween = function (v1, v2) {
         var _this = this;
         var paths = [];
@@ -192,6 +268,11 @@ var AbstractGraph = /** @class */ (function () {
         dfs(vertex1, vertex2, new Map(), []);
         return paths;
     };
+    /**
+     * The function calculates the sum of weights along a given path.
+     * @param {V[]} path - An array of vertices (V) representing a path in a graph.
+     * @returns The function `getPathSumWeight` returns the sum of the weights of the edges in the given path.
+     */
     AbstractGraph.prototype.getPathSumWeight = function (path) {
         var _a;
         var sum = 0;
@@ -200,6 +281,20 @@ var AbstractGraph = /** @class */ (function () {
         }
         return sum;
     };
+    /**
+     * The function `getMinCostBetween` calculates the minimum cost between two vertices in a graph, either based on edge
+     * weights or using a breadth-first search algorithm.
+     * @param {V | VertexId} v1 - The parameter `v1` represents the starting vertex or vertex ID of the graph.
+     * @param {V | VertexId} v2 - The parameter `v2` represents the second vertex in the graph. It can be either a vertex
+     * object or a vertex ID.
+     * @param {boolean} [isWeight] - isWeight is an optional parameter that indicates whether the graph edges have weights.
+     * If isWeight is set to true, the function will calculate the minimum cost between v1 and v2 based on the weights of
+     * the edges. If isWeight is set to false or not provided, the function will calculate the
+     * @returns The function `getMinCostBetween` returns a number representing the minimum cost between two vertices (`v1`
+     * and `v2`) in a graph. If the `isWeight` parameter is `true`, it calculates the minimum weight between the vertices.
+     * If `isWeight` is `false` or not provided, it calculates the minimum number of edges between the vertices. If the
+     * vertices are not
+     */
     AbstractGraph.prototype.getMinCostBetween = function (v1, v2, isWeight) {
         var e_3, _a, e_4, _b;
         if (isWeight === undefined)
@@ -265,6 +360,18 @@ var AbstractGraph = /** @class */ (function () {
             return null;
         }
     };
+    /**
+     * The function `getMinPathBetween` returns the minimum path between two vertices in a graph, either based on weight or
+     * using a breadth-first search algorithm.
+     * @param {V | VertexId} v1 - The parameter `v1` represents the starting vertex or its ID.
+     * @param {V | VertexId} v2 - The parameter `v2` represents the destination vertex or its ID. It is the vertex that we
+     * want to find the minimum path to from the source vertex `v1`.
+     * @param {boolean} [isWeight] - A boolean flag indicating whether to consider the weight of edges in finding the
+     * minimum path. If set to true, the function will use Dijkstra's algorithm to find the minimum weighted path. If set
+     * to false, the function will use breadth-first search (BFS) to find the minimum path. If
+     * @returns The function `getMinPathBetween` returns an array of vertices (`V[]`) representing the minimum path between
+     * two vertices (`v1` and `v2`). If no path is found, it returns `null`.
+     */
     AbstractGraph.prototype.getMinPathBetween = function (v1, v2, isWeight) {
         var e_5, _a;
         var _this = this;
@@ -339,10 +446,20 @@ var AbstractGraph = /** @class */ (function () {
     };
     /**
      * Dijkstra algorithm time: O(VE) space: O(V + E)
-     * @param src
-     * @param dest
-     * @param getMinDist
-     * @param genPaths
+     * The function `dijkstraWithoutHeap` implements Dijkstra's algorithm to find the shortest path between two vertices in
+     * a graph without using a heap data structure.
+     * @param {V | VertexId} src - The source vertex from which to start the Dijkstra's algorithm. It can be either a
+     * vertex object or a vertex ID.
+     * @param {V | VertexId | null} [dest] - The `dest` parameter in the `dijkstraWithoutHeap` function is an optional
+     * parameter that specifies the destination vertex for the Dijkstra algorithm. It can be either a vertex object or its
+     * identifier. If no destination is provided, the value is set to `null`.
+     * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
+     * distance from the source vertex to the destination vertex should be calculated and returned in the result. If
+     * `getMinDist` is set to `true`, the `minDist` property in the result will contain the minimum distance
+     * @param {boolean} [genPaths] - The `genPaths` parameter is a boolean flag that determines whether or not to generate
+     * paths in the Dijkstra algorithm. If `genPaths` is set to `true`, the algorithm will calculate and return the
+     * shortest paths from the source vertex to all other vertices in the graph. If `genPaths
+     * @returns The function `dijkstraWithoutHeap` returns an object of type `DijkstraResult<V>`.
      */
     AbstractGraph.prototype.dijkstraWithoutHeap = function (src, dest, getMinDist, genPaths) {
         var e_7, _a, e_8, _b;
@@ -490,10 +607,20 @@ var AbstractGraph = /** @class */ (function () {
     };
     /**
      * Dijkstra algorithm time: O(logVE) space: O(V + E)
-     * @param src
-     * @param dest
-     * @param getMinDist
-     * @param genPaths
+     * The `dijkstra` function implements Dijkstra's algorithm to find the shortest path between a source vertex and an
+     * optional destination vertex, and optionally returns the minimum distance, the paths, and other information.
+     * @param {V | VertexId} src - The `src` parameter represents the source vertex from which the Dijkstra algorithm will
+     * start. It can be either a vertex object or a vertex ID.
+     * @param {V | VertexId | null} [dest] - The `dest` parameter is the destination vertex or vertex ID. It specifies the
+     * vertex to which the shortest path is calculated from the source vertex. If no destination is provided, the algorithm
+     * will calculate the shortest paths to all other vertices from the source vertex.
+     * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
+     * distance from the source vertex to the destination vertex should be calculated and returned in the result. If
+     * `getMinDist` is set to `true`, the `minDist` property in the result will contain the minimum distance
+     * @param {boolean} [genPaths] - The `genPaths` parameter is a boolean flag that determines whether or not to generate
+     * paths in the Dijkstra algorithm. If `genPaths` is set to `true`, the algorithm will calculate and return the
+     * shortest paths from the source vertex to all other vertices in the graph. If `genPaths
+     * @returns The function `dijkstra` returns an object of type `DijkstraResult<V>`.
      */
     AbstractGraph.prototype.dijkstra = function (src, dest, getMinDist, genPaths) {
         var e_11, _a, e_12, _b;
@@ -628,10 +755,17 @@ var AbstractGraph = /** @class */ (function () {
     /**
      * BellmanFord time:O(VE) space:O(V)
      * one to rest pairs
-     * @param src
-     * @param scanNegativeCycle
-     * @param getMin
-     * @param genPath
+     * The `bellmanFord` function implements the Bellman-Ford algorithm to find the shortest path from a source vertex to
+     * all other vertices in a graph, and optionally detects negative cycles and generates the minimum path.
+     * @param {V | VertexId} src - The `src` parameter is the source vertex from which the Bellman-Ford algorithm will
+     * start calculating the shortest paths. It can be either a vertex object or a vertex ID.
+     * @param {boolean} [scanNegativeCycle] - A boolean flag indicating whether to scan for negative cycles in the graph.
+     * @param {boolean} [getMin] - The `getMin` parameter is a boolean flag that determines whether the algorithm should
+     * calculate the minimum distance from the source vertex to all other vertices in the graph. If `getMin` is set to
+     * `true`, the algorithm will find the minimum distance and update the `min` variable with the minimum
+     * @param {boolean} [genPath] - A boolean flag indicating whether to generate paths for all vertices from the source
+     * vertex.
+     * @returns The function `bellmanFord` returns an object with the following properties:
      */
     AbstractGraph.prototype.bellmanFord = function (src, scanNegativeCycle, getMin, genPath) {
         var e_14, _a;
@@ -732,6 +866,12 @@ var AbstractGraph = /** @class */ (function () {
     /**
      * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
      * all pairs
+     * The function implements the Floyd-Warshall algorithm to find the shortest path between all pairs of vertices in a
+     * graph.
+     * @returns The function `floyd()` returns an object with two properties: `costs` and `predecessor`. The `costs`
+     * property is a 2D array of numbers representing the shortest path costs between vertices in a graph. The
+     * `predecessor` property is a 2D array of vertices (or `null`) representing the predecessor vertices in the shortest
+     * path between vertices in the
      */
     AbstractGraph.prototype.floyd = function () {
         var _a;
@@ -771,6 +911,20 @@ var AbstractGraph = /** @class */ (function () {
      * Tarjan can find the articulation points and bridges(critical edges) 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} [needArticulationPoints] - A boolean value indicating whether or not to calculate and return the
+     * articulation points in the graph. Articulation points are the vertices 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
+     * (edges 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 vertices that form cycles within the SCCs.
+     * @returns The function `tarjan` returns an object with the following properties:
      */
     AbstractGraph.prototype.tarjan = function (needArticulationPoints, needBridges, needSCCs, needCycles) {
         // !! in undirected graph we will not let child visit parent when DFS