data-structure-typed 1.50.2 → 1.50.3

package/src/data-structures/binary-tree/segment-tree.ts

@@ -9,18 +9,136 @@
 import type { SegmentTreeNodeVal } from '../../types';
 
 export class SegmentTreeNode {
-  start = 0;
-  end = 0;
-  value: SegmentTreeNodeVal | undefined = undefined;
-  sum = 0;
-  left: SegmentTreeNode | undefined = undefined;
-  right: SegmentTreeNode | undefined = undefined;
-
+  /**
+   * The constructor initializes the properties of a SegmentTreeNode object.
+   * @param {number} start - The `start` parameter represents the starting index of the segment covered
+   * by this node in a segment tree.
+   * @param {number} end - The `end` parameter represents the end index of the segment covered by this
+   * node in a segment tree.
+   * @param {number} sum - The `sum` parameter represents the sum of the values in the range covered by
+   * the segment tree node.
+   * @param {SegmentTreeNodeVal | undefined} [value] - The `value` parameter is an optional parameter
+   * of type `SegmentTreeNodeVal`. It represents the value associated with the segment tree node.
+   */
   constructor(start: number, end: number, sum: number, value?: SegmentTreeNodeVal | undefined) {
-    this.start = start;
-    this.end = end;
-    this.sum = sum;
-    this.value = value || undefined;
+    this._start = start;
+    this._end = end;
+    this._sum = sum;
+    this._value = value || undefined;
+  }
+
+  protected _start = 0;
+
+  /**
+   * The function returns the value of the protected variable _start.
+   * @returns The start value, which is of type number.
+   */
+  get start(): number {
+    return this._start;
+  }
+
+  /**
+   * The above function sets the value of the "start" property.
+   * @param {number} value - The value parameter is of type number.
+   */
+  set start(value: number) {
+    this._start = value;
+  }
+
+  protected _end = 0;
+
+  /**
+   * The function returns the value of the protected variable `_end`.
+   * @returns The value of the protected property `_end`.
+   */
+  get end(): number {
+    return this._end;
+  }
+
+  /**
+   * The above function sets the value of the "end" property.
+   * @param {number} value - The value parameter is a number that represents the new value for the end
+   * property.
+   */
+  set end(value: number) {
+    this._end = value;
+  }
+
+  protected _value: SegmentTreeNodeVal | undefined = undefined;
+
+  /**
+   * The function returns the value of a segment tree node.
+   * @returns The value being returned is either a `SegmentTreeNodeVal` object or `undefined`.
+   */
+  get value(): SegmentTreeNodeVal | undefined {
+    return this._value;
+  }
+
+  /**
+   * The function sets the value of a segment tree node.
+   * @param {SegmentTreeNodeVal | undefined} value - The `value` parameter is of type
+   * `SegmentTreeNodeVal` or `undefined`.
+   */
+  set value(value: SegmentTreeNodeVal | undefined) {
+    this._value = value;
+  }
+
+  protected _sum = 0;
+
+  /**
+   * The function returns the value of the sum property.
+   * @returns The method is returning the value of the variable `_sum`.
+   */
+  get sum(): number {
+    return this._sum;
+  }
+
+  /**
+   * The above function sets the value of the sum property.
+   * @param {number} value - The parameter "value" is of type "number".
+   */
+  set sum(value: number) {
+    this._sum = value;
+  }
+
+  protected _left: SegmentTreeNode | undefined = undefined;
+
+  /**
+   * The function returns the left child of a segment tree node.
+   * @returns The `left` property of the `SegmentTreeNode` object is being returned. It is of type
+   * `SegmentTreeNode` or `undefined`.
+   */
+  get left(): SegmentTreeNode | undefined {
+    return this._left;
+  }
+
+  /**
+   * The function sets the value of the left property of a SegmentTreeNode object.
+   * @param {SegmentTreeNode | undefined} value - The value parameter is of type SegmentTreeNode or
+   * undefined.
+   */
+  set left(value: SegmentTreeNode | undefined) {
+    this._left = value;
+  }
+
+  protected _right: SegmentTreeNode | undefined = undefined;
+
+  /**
+   * The function returns the right child of a segment tree node.
+   * @returns The `getRight()` method is returning a value of type `SegmentTreeNode` or `undefined`.
+   */
+  get right(): SegmentTreeNode | undefined {
+    return this._right;
+  }
+
+  /**
+   * The function sets the right child of a segment tree node.
+   * @param {SegmentTreeNode | undefined} value - The `value` parameter is of type `SegmentTreeNode |
+   * undefined`. This means that it can accept either a `SegmentTreeNode` object or `undefined` as its
+   * value.
+   */
+  set right(value: SegmentTreeNode | undefined) {
+    this._right = value;
   }
 }
 
@@ -51,24 +169,40 @@ export class SegmentTree {
 
   protected _values: number[] = [];
 
+  /**
+   * The function returns an array of numbers.
+   * @returns An array of numbers is being returned.
+   */
   get values(): number[] {
     return this._values;
   }
 
   protected _start = 0;
 
+  /**
+   * The function returns the value of the protected variable _start.
+   * @returns The start value, which is of type number.
+   */
   get start(): number {
     return this._start;
   }
 
   protected _end: number;
 
+  /**
+   * The function returns the value of the protected variable `_end`.
+   * @returns The value of the protected property `_end`.
+   */
   get end(): number {
     return this._end;
   }
 
   protected _root: SegmentTreeNode | undefined;
 
+  /**
+   * The function returns the root node of a segment tree.
+   * @returns The `root` property of the class `SegmentTreeNode` or `undefined` if it is not defined.
+   */
   get root(): SegmentTreeNode | undefined {
     return this._root;
   }

package/src/data-structures/binary-tree/tree-multimap.ts

@@ -23,8 +23,6 @@ export class TreeMultimapNode<
   V = any,
   NODE extends TreeMultimapNode<K, V, NODE> = TreeMultimapNodeNested<K, V>
 > extends AVLTreeNode<K, V, NODE> {
-  count: number;
-
   /**
    * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
    * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
@@ -39,6 +37,25 @@ export class TreeMultimapNode<
     super(key, value);
     this.count = count;
   }
+
+  protected _count: number = 1;
+
+  /**
+   * The function returns the value of the protected variable _count.
+   * @returns The count property of the object, which is of type number.
+   */
+  get count(): number {
+    return this._count;
+  }
+
+  /**
+   * The above function sets the value of the count property.
+   * @param {number} value - The value parameter is of type number, which means it can accept any
+   * numeric value.
+   */
+  set count(value: number) {
+    this._count = value;
+  }
 }
 
 /**
@@ -57,9 +74,14 @@ export class TreeMultimap<
     if (keysOrNodesOrEntries) this.addMany(keysOrNodesOrEntries);
   }
 
-  private _count = 0;
+  protected _count = 0;
 
   // TODO the _count is not accurate after nodes count modified
+  /**
+   * The function calculates the sum of the count property of all nodes in a tree using depth-first
+   * search.
+   * @returns the sum of the count property of all nodes in the tree.
+   */
   get count(): number {
     let sum = 0;
     this.dfs(node => (sum += node.count));
@@ -79,6 +101,15 @@ export class TreeMultimap<
     return new TreeMultimapNode(key, value, count) as NODE;
   }
 
+  /**
+   * The function creates a new TreeMultimap object with the specified options and returns it.
+   * @param [options] - The `options` parameter is an optional object that contains additional
+   * configuration options for creating the `TreeMultimap` object. It can include properties such as
+   * `iterationType` and `variant`, which are used to specify the type of iteration and the variant of
+   * the tree, respectively. These properties can be
+   * @returns a new instance of the `TreeMultimap` class, with the provided options merged with the
+   * default options. The returned value is casted as `TREE`.
+   */
   override createTree(options?: TreeMultimapOptions<K>): TREE {
     return new TreeMultimap<K, V, NODE, TREE>([], {
       iterationType: this.iterationType,
@@ -375,6 +406,14 @@ export class TreeMultimap<
     return undefined;
   }
 
+  /**
+   * The function replaces an old node with a new node and updates the count property of the new node.
+   * @param {NODE} oldNode - The `oldNode` parameter is of type `NODE` and represents the node that
+   * needs to be replaced in a data structure.
+   * @param {NODE} newNode - The `newNode` parameter is an object of type `NODE`.
+   * @returns The method is returning the result of calling the `_replaceNode` method from the
+   * superclass, after updating the `count` property of the `newNode` object.
+   */
   protected _replaceNode(oldNode: NODE, newNode: NODE): NODE {
     newNode.count = oldNode.count + newNode.count;
     return super._replaceNode(oldNode, newNode);

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

@@ -954,217 +954,6 @@ export abstract class AbstractGraph<
     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: boolean = false,
-    needBridges: boolean = false,
-    needSCCs: boolean = true,
-    needCycles: boolean = 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: Map<VO, number> = new Map();
-    const lowMap: Map<VO, number> = new Map();
-    const vertexMap = this._vertexMap;
-    vertexMap.forEach(v => {
-      dfnMap.set(v, -1);
-      lowMap.set(v, Infinity);
-    });
-
-    const [root] = vertexMap.values();
-
-    const cutVertexes: VO[] = [];
-    const bridges: EO[] = [];
-    let dfn = 0;
-    const dfs = (cur: VO, parent: VO | undefined) => {
-      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: Map<number, VO[]> = new Map();
-
-    const getSCCs = () => {
-      const SCCs: Map<number, VO[]> = new Map();
-      lowMap.forEach((low, vertex) => {
-        if (!SCCs.has(low)) {
-          SCCs.set(low, [vertex]);
-        } else {
-          SCCs.get(low)?.push(vertex);
-        }
-      });
-      return SCCs;
-    };
-
-    if (needSCCs) {
-      SCCs = getSCCs();
-    }
-
-    const cycles: Map<number, VO[]> = new Map();
-
-    if (needCycles) {
-      const visitedMap: Map<VO, boolean> = new Map();
-      const stack: VO[] = [];
-      const findCyclesDFS = (cur: VO, parent: VO | undefined) => {
-        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(): Map<VO, number> {
-    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(): Map<VO, number> {
-    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(): VO[] {
-    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(): Map<number, VO[]> {
-    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/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)