added calc-equation & critical-connections

Author: shkvik

src/graph/calc-equation.ts

@@ -0,0 +1,88 @@
+function calcEquation(
+  equations: string[][],
+  values: number[],
+  queries: string[][]
+): number[] {
+  const graph = new Map<string, Map<string, number>>();
+  const result: number[] = [];
+  
+  for (let i = 0; i < equations.length; i++) {
+    const [a, b] = equations[i];
+    const value = values[i];
+  
+    if (!graph.has(a)) graph.set(a, new Map());
+    if (!graph.has(b)) graph.set(b, new Map());
+  
+    graph.get(a).set(b, value);
+    graph.get(b).set(a, 1/value);
+  }
+  
+  const dfs = (start: string, end: string, visited: Set<string>): number => {
+    if (!graph.has(start) || !graph.has(end)) {
+      return -1.0;
+    }
+    if (start === end) {
+      return 1.0;
+    }
+    visited.add(start);
+
+    for (const [neighbor, neighborVal] of graph.get(start)) {
+      if (!visited.has(neighbor)) {
+        const result = dfs(neighbor, end, visited);
+        if (result !== -1.0) {
+          return result * neighborVal
+        }
+      }
+    }
+    return -1.0;
+  }
+
+  for (const [d, c] of queries) {
+    const visited = new Set<string>();
+    result.push(dfs(d, c, visited));
+  }
+
+  return result;
+};
+
+export function calcEquationDBG() {
+  const tests = [
+    {
+      input: {
+        equations: [["a", "b"], ["b", "c"]],
+        values: [2.0, 3.0],
+        queries: [["a", "c"], ["b", "a"], ["a", "e"], ["a", "a"], ["x", "x"]]
+      },
+      expected: [6.0, 0.5, -1.0, 1.0, -1.0]
+    },
+    {
+      input: {
+        equations: [["a", "b"], ["b", "c"], ["bc", "cd"]],
+        values: [1.5, 2.5, 5.0],
+        queries: [["a", "c"], ["c", "b"], ["bc", "cd"], ["cd", "bc"]]
+      },
+      expected: [3.75, 0.4, 5.0, 0.2]
+    },
+    {
+      input: {
+        equations: [["a", "b"]],
+        values: [0.5],
+        queries: [["a", "b"], ["b", "a"], ["a", "c"], ["x", "y"]]
+      },
+      expected: [0.5, 2.0, -1.0, -1.0]
+    }
+  ];
+  
+  tests.forEach((test, index) => {
+    const result = calcEquation(test.input.equations, test.input.values, test.input.queries);
+    const success = JSON.stringify(result) === JSON.stringify(test.expected);
+    if (success) {
+      console.log(`Test ${index} success`);
+    } else {
+      console.log(`Test ${index} fail`);
+      console.log(`expected: ${JSON.stringify(test.expected)}`);
+      console.log(`got: ${JSON.stringify(result)}`);
+    }
+  });
+  
+}

src/graph/critical-connections.ts

@@ -1,54 +1,73 @@
+function criticalConnectionsEZ(n: number, connections: number[][]): number[][] {
+  const graph: number[][] = Array.from({ length: n }, () => []);
+  const result: number[][] = [];
 
-const connections = [
-  [0,1],
-  [1,2],
-  [2,0],
-  [1,3]
-]
+  for (const [u, v] of connections) {
+    graph[u].push(v);
+    graph[v].push(u);
+  }
+
+  const isConnected = (removedEdge: [number, number]) => {
+    const visited: boolean[] = new Array(n).fill(false);
+    let count = 0;
+    const dfs = (u: number) => {
+      visited[u] = true;
+      count++;
+      for (const v of graph[u]) {
+        if (!visited[v] 
+            && !(u === removedEdge[0] && v === removedEdge[1]) 
+            && !(u === removedEdge[1] && v === removedEdge[0])
+        ) {
+          dfs(v);
+        }
+      }
+    };
+    dfs(0);
+    return count === n;
+  };
+
+  for (const [u, v] of connections) {
+    if (!isConnected([u, v])) {
+      result.push([u, v]);
+    }
+  }
+
+  return result;
+}
 
 function criticalConnections(n: number, connections: number[][]): number[][] {
   const graph: number[][] = Array.from({ length: n }, () => []);
   const result: number[][] = [];
-  const disc: number[] = new Array(n).fill(-1); // Время открытия вершины
-  const low: number[] = new Array(n).fill(-1);  // Минимальное время посещения
+  const disc: number[] = new Array(n).fill(-1);
+  const low: number[] = new Array(n).fill(-1);
   let time = 0;
 
-  // Построение графа
   for (const [u, v] of connections) {
     graph[u].push(v);
     graph[v].push(u);
   }
-
-  // Основная функция DFS
   const dfs = (u: number, parent: number) => {
-    disc[u] = low[u] = time++; // Инициализация времени открытия и low
+    disc[u] = low[u] = time++;
     for (const v of graph[u]) {
-      if (v === parent) continue; // Игнорируем родительскую вершину
-
-      if (disc[v] === -1) { // Если вершина v еще не посещена
-        dfs(v, u); // Рекурсивный DFS
-
-        // Обновляем low[u] на основе дочерней вершины v
+      if (v === parent){
+        continue;
+      }; 
+      if (disc[v] === -1) {
+        dfs(v, u); 
         low[u] = Math.min(low[u], low[v]);
-
-        // Если low[v] > disc[u], то (u, v) — критическое соединение
         if (low[v] > disc[u]) {
           result.push([u, v]);
         }
       } else {
-        // Обратное ребро, обновляем low[u]
         low[u] = Math.min(low[u], disc[v]);
       }
     }
   };
-
-  // Запуск DFS для всех вершин
   for (let i = 0; i < n; i++) {
     if (disc[i] === -1) {
-      dfs(i, -1); // -1 означает, что у начальной вершины нет родителя
+      dfs(i, -1);
     }
   }
-
   return result;
 }
 
@@ -58,12 +77,16 @@ export function criticalConnectionsDBG(){
   const tests = [
     {
       input: { n: 4, connections: [[0, 1], [1, 2], [2, 0], [1, 3]] },
-      result: [[1, 3]] // Соединение [1, 3] является критическим
+      result: [[1, 3]]
     },
     {
       input: { n: 2, connections: [[0, 1]] },
-      result: [[0, 1]] // Единственное соединение [0, 1] является критическим
+      result: [[0, 1]] 
     },
+    {
+      input: { n: 6, connections: [[0, 1], [1, 2], [1, 3], [3, 4], [4, 5], [2, 5]] },
+      result: [[0, 1]] 
+    }
   ];
 
   tests.forEach((test, index) => {

src/main.ts

@@ -1,9 +1,5 @@
+import { calcEquationDBG } from "./graph/calc-equation";
 import { criticalConnectionsDBG } from "./graph/critical-connections";
 
-criticalConnectionsDBG()
-
-
-
-
-
 
+calcEquationDBG()

src/worker/test.ts

@@ -0,0 +1,13 @@
+import workerpool from 'workerpool';
+
+function longComputationTask(input: number): number {
+  let result = 0;
+  for (let i = 0; i < 1e9; i++) {
+    result += Math.sin(input + i);
+  }
+  return result;
+}
+
+workerpool.worker({
+  longComputationTask: longComputationTask
+});

src/worker/worker.ts

@@ -0,0 +1,19 @@
+import workerpool from 'workerpool';
+
+// Задача с задержкой, которая симулирует долгую операцию
+function longComputationTask(input: number): Promise<string> {
+  console.log(`Task ${input} started`);
+
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      const result = `Task ${input} completed`;
+      console.log(result);
+      resolve(result);
+    }, 5000); // Задержка 5 секунд для демонстрации параллельной работы
+  });
+}
+
+// Экспортируем задачу через workerpool
+workerpool.worker({
+  longComputationTask: longComputationTask
+});

tsconfig.json

@@ -17,6 +17,7 @@
     "strictBindCallApply": false,
     "forceConsistentCasingInFileNames": false,
     "noFallthroughCasesInSwitch": false,
+    "esModuleInterop": true,
   },
   "include": ["src", "test"]
 }