data-structure-typed 0.8.18 → 1.12.9

package/dist/data-structures/binary-tree/segment-tree.js

@@ -1,44 +1,12 @@
 "use strict";
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SegmentTree = exports.SegmentTreeNode = void 0;
-class SegmentTreeNode {
-    get start() {
-        return this._start;
-    }
-    set start(v) {
-        this._start = v;
-    }
-    get end() {
-        return this._end;
-    }
-    set end(v) {
-        this._end = v;
-    }
-    get val() {
-        return this._val;
-    }
-    set val(v) {
-        this._val = v;
-    }
-    get sum() {
-        return this._sum;
-    }
-    set sum(v) {
-        this._sum = v;
-    }
-    get left() {
-        return this._left;
-    }
-    set left(v) {
-        this._left = v;
-    }
-    get right() {
-        return this._right;
-    }
-    set right(v) {
-        this._right = v;
-    }
-    constructor(start, end, sum, val) {
+var SegmentTreeNode = /** @class */ (function () {
+    function SegmentTreeNode(start, end, sum, val) {
         this._start = 0;
         this._end = 0;
         this._val = null;
@@ -50,13 +18,71 @@ class SegmentTreeNode {
         this._sum = sum;
         this._val = val || null;
     }
-}
+    Object.defineProperty(SegmentTreeNode.prototype, "start", {
+        get: function () {
+            return this._start;
+        },
+        set: function (v) {
+            this._start = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SegmentTreeNode.prototype, "end", {
+        get: function () {
+            return this._end;
+        },
+        set: function (v) {
+            this._end = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SegmentTreeNode.prototype, "val", {
+        get: function () {
+            return this._val;
+        },
+        set: function (v) {
+            this._val = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SegmentTreeNode.prototype, "sum", {
+        get: function () {
+            return this._sum;
+        },
+        set: function (v) {
+            this._sum = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SegmentTreeNode.prototype, "left", {
+        get: function () {
+            return this._left;
+        },
+        set: function (v) {
+            this._left = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SegmentTreeNode.prototype, "right", {
+        get: function () {
+            return this._right;
+        },
+        set: function (v) {
+            this._right = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return SegmentTreeNode;
+}());
 exports.SegmentTreeNode = SegmentTreeNode;
-class SegmentTree {
-    get root() {
-        return this._root;
-    }
-    constructor(values, start, end) {
+var SegmentTree = /** @class */ (function () {
+    function SegmentTree(values, start, end) {
         this._values = [];
         this._start = 0;
         start = start || 0;
@@ -66,30 +92,37 @@ class SegmentTree {
         this._end = end;
         this._root = this.build(start, end);
     }
-    build(start, end) {
+    Object.defineProperty(SegmentTree.prototype, "root", {
+        get: function () {
+            return this._root;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    SegmentTree.prototype.build = function (start, end) {
         if (start === end) {
             return new SegmentTreeNode(start, end, this._values[start]);
         }
-        const mid = start + Math.floor((end - start) / 2);
-        const left = this.build(start, mid);
-        const right = this.build(mid + 1, end);
-        const cur = new SegmentTreeNode(start, end, left.sum + right.sum);
+        var mid = start + Math.floor((end - start) / 2);
+        var left = this.build(start, mid);
+        var right = this.build(mid + 1, end);
+        var cur = new SegmentTreeNode(start, end, left.sum + right.sum);
         cur.left = left;
         cur.right = right;
         return cur;
-    }
-    updateNode(index, sum, val) {
-        const root = this.root || null;
+    };
+    SegmentTree.prototype.updateNode = function (index, sum, val) {
+        var root = this.root || null;
         if (!root) {
             return;
         }
-        const dfs = (cur, index, sum, val) => {
+        var dfs = function (cur, index, sum, val) {
             if (cur.start === cur.end && cur.start === index) {
                 cur.sum = sum;
                 // cur.val = val;
                 return;
             }
-            const mid = cur.start + Math.floor((cur.end - cur.start) / 2);
+            var mid = cur.start + Math.floor((cur.end - cur.start) / 2);
             if (index <= mid) {
                 if (cur.left) {
                     dfs(cur.left, index, sum, val);
@@ -105,17 +138,17 @@ class SegmentTree {
             }
         };
         dfs(root, index, sum);
-    }
-    querySumByRange(indexA, indexB) {
-        const root = this.root || null;
+    };
+    SegmentTree.prototype.querySumByRange = function (indexA, indexB) {
+        var root = this.root || null;
         if (!root) {
             return 0;
         }
-        const dfs = (cur, i, j) => {
+        var dfs = function (cur, i, j) {
             if (cur.start === i && cur.end === j) {
                 return cur.sum;
             }
-            const mid = cur.start + Math.floor((cur.end - cur.start) / 2);
+            var mid = cur.start + Math.floor((cur.end - cur.start) / 2);
             if (j <= mid) {
                 // TODO after no-non-null-assertion not ensure the logic
                 if (cur.left) {
@@ -146,6 +179,7 @@ class SegmentTree {
             }
         };
         return dfs(root, indexA, indexB);
-    }
-}
+    };
+    return SegmentTree;
+}());
 exports.SegmentTree = SegmentTree;

package/dist/data-structures/binary-tree/splay-tree.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SplayTree = void 0;
-class SplayTree {
-}
+var SplayTree = /** @class */ (function () {
+    function SplayTree() {
+    }
+    return SplayTree;
+}());
 exports.SplayTree = SplayTree;

package/dist/data-structures/binary-tree/tree-multiset.d.ts

@@ -1,9 +1,9 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 import { BST, BSTNode } from './bst';
-import { BinaryTreeNodeId } from './binary-tree';
-export type TreeMultiSetDeletedResult<T> = {
-    deleted: BSTNode<T> | null;
-    needBalanced: BSTNode<T> | null;
-};
+import type { BinaryTreeNodeId, TreeMultiSetDeletedResult } from '../types';
 export declare class TreeMultiSet<T> extends BST<T> {
     createNode(id: BinaryTreeNodeId, val: T, count?: number): BSTNode<T>;
     put(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | null;

package/dist/data-structures/binary-tree/tree-multiset.js

@@ -1,16 +1,40 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeMultiSet = void 0;
-const bst_1 = require("./bst");
-class TreeMultiSet extends bst_1.BST {
-    createNode(id, val, count) {
-        return new bst_1.BSTNode(id, val, count);
-    }
-    put(id, val, count) {
-        return super.put(id, val, count);
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
+var bst_1 = require("./bst");
+var TreeMultiSet = /** @class */ (function (_super) {
+    __extends(TreeMultiSet, _super);
+    function TreeMultiSet() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-    remove(id, isUpdateAllLeftSum) {
-        return super.remove(id, isUpdateAllLeftSum);
-    }
-}
+    TreeMultiSet.prototype.createNode = function (id, val, count) {
+        return new bst_1.BSTNode(id, val, count);
+    };
+    TreeMultiSet.prototype.put = function (id, val, count) {
+        return _super.prototype.put.call(this, id, val, count);
+    };
+    TreeMultiSet.prototype.remove = function (id, isUpdateAllLeftSum) {
+        return _super.prototype.remove.call(this, id, isUpdateAllLeftSum);
+    };
+    return TreeMultiSet;
+}(bst_1.BST));
 exports.TreeMultiSet = TreeMultiSet;

package/dist/data-structures/binary-tree/two-three-tree.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TwoThreeTree = void 0;
-class TwoThreeTree {
-}
+var TwoThreeTree = /** @class */ (function () {
+    function TwoThreeTree() {
+    }
+    return TwoThreeTree;
+}());
 exports.TwoThreeTree = TwoThreeTree;

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

@@ -1,95 +1,197 @@
-export type VertexId = string | number;
-export type DijkstraResult<V> = {
-    distMap: Map<V, number>;
-    preMap: Map<V, V | null>;
-    seen: Set<V>;
-    paths: V[][];
-    minDist: number;
-    minPath: V[];
-} | null;
-export interface I_Graph<V, E> {
-    containsVertex(vertexOrId: V | VertexId): boolean;
-    getVertex(vertexOrId: VertexId | V): V | null;
-    getVertexId(vertexOrId: V | VertexId): VertexId;
-    vertexSet(): Map<VertexId, V>;
-    addVertex(v: V): boolean;
-    removeVertex(vertexOrId: V | VertexId): boolean;
-    removeAllVertices(vertices: V[] | VertexId[]): boolean;
-    degreeOf(vertexOrId: V | VertexId): number;
-    edgesOf(vertexOrId: V | VertexId): E[];
-    containsEdge(src: V | VertexId, dest: V | VertexId): boolean;
-    getEdge(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
-    edgeSet(): E[];
-    addEdge(edge: E): boolean;
-    removeEdgeBetween(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
-    removeEdge(edge: E): E | null;
-    setEdgeWeight(srcOrId: V | VertexId, destOrId: V | VertexId, weight: number): boolean;
-    getMinPathBetween(v1: V | VertexId, v2: V | VertexId, isWeight?: boolean): V[] | null;
-    getNeighbors(vertexOrId: V | VertexId): V[];
-}
+import type { DijkstraResult, IGraph, VertexId } from '../types';
 export declare class AbstractVertex {
-    private _id;
+    constructor(id: VertexId);
+    protected _id: VertexId;
     get id(): VertexId;
     set id(v: VertexId);
-    constructor(id: VertexId);
 }
 export declare abstract class AbstractEdge {
+    static DEFAULT_EDGE_WEIGHT: number;
+    protected constructor(weight?: number);
     private _weight;
     get weight(): number;
     set weight(v: number);
     private _hashCode;
     get hashCode(): string;
     set hashCode(v: string);
-    protected constructor(weight?: number);
-    static DEFAULT_EDGE_WEIGHT: number;
 }
-export declare abstract class AbstractGraph<V extends AbstractVertex, E extends AbstractEdge> implements I_Graph<V, E> {
+export declare abstract class AbstractGraph<V extends AbstractVertex, E extends AbstractEdge> implements IGraph<V, E> {
     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;
@@ -102,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[][];
@@ -114,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>;