View difference between Paste ID: Q4WW872Y and dRa0W47a

 class MetroGraph {
-  constructor() {
+    constructor() {
-    this.stations = {};
+        this.stations = {};
-  }
+
 
-  addStation(stationName) {
+    addStation(stationName) {
-    this.stations[stationName] = {};
+        this.stations[stationName] = {};
-  }
+
 
-  addConnection(stationA, stationB, time) {
+    addConnection(stationA, stationB, time) {
-    this.stations[stationA][stationB] = time;
+        this.stations[stationA][stationB] = time;
-    this.stations[stationB][stationA] = time;
+        this.stations[stationB][stationA] = time;
-  }
+
 
-  dijkstra(startStation, endStation) {
+    dijkstraWithMultiplePaths(startStation, endStation, numberOfPaths = 3) {
-    const distances = {};
+        const paths = [];
-    const visited = {};
+
-    const path = {};
+        for (let pathNumber = 0; pathNumber < numberOfPaths; pathNumber++) {
             const distances = {};
-    // Инициализация начальных расстояний и пути
+            const visited = {};
-    for (const station in this.stations) {
+            const path = {};
-      distances[station] = Infinity;
+
-      visited[station] = false;
+            // Инициализация начальных расстояний и пути
-      path[station] = null;
+            for (const station in this.stations) {
                 distances[station] = Infinity;
                 visited[station] = false;
-    distances[startStation] = 0;
+                path[station] = null;
             }
-    // Шаги алгоритма Дейкстры
+
-    while (true) {
+            distances[startStation] = 0;
-      let currentStation = null;
+
-      let currentDistance = Infinity;
+            // Шаги алгоритма Дейкстры
             while (true) {
-      // Находим ближайшую непосещенную станцию
+                let currentStation = null;
-      for (const station in this.stations) {
+                let currentDistance = Infinity;
-        if (!visited[station] && distances[station] < currentDistance) {
+
-          currentStation = station;
+                // Находим ближайшую непосещенную станцию
-          currentDistance = distances[station];
+                for (const station in this.stations) {
                     if (!visited[station] && distances[station] < currentDistance) {
-      }
+                        currentStation = station;
                         currentDistance = distances[station];
-      // Если все станции посещены, выходим из цикла
+                    }
-      if (currentStation === null) break;
+                }
 
-      // Посещаем текущую станцию
+                // Если все станции посещены, выходим из цикла
-      visited[currentStation] = true;
+                if (currentStation === null) break;
 
-      // Обновляем расстояния до соседних станций
+                // Посещаем текущую станцию
-      for (const neighborStation in this.stations[currentStation]) {
+                visited[currentStation] = true;
-        const timeToNeighbor = this.stations[currentStation][neighborStation];
+
-        const totalDistance = distances[currentStation] + timeToNeighbor;
+                // Обновляем расстояния до соседних станций
                 for (const neighborStation in this.stations[currentStation]) {
-        if (totalDistance < distances[neighborStation]) {
+                    const timeToNeighbor = this.stations[currentStation][neighborStation];
-          distances[neighborStation] = totalDistance;
+                    const totalDistance = distances[currentStation] + timeToNeighbor;
-          path[neighborStation] = currentStation;
+
                     if (totalDistance < distances[neighborStation]) {
-      }
+                        distances[neighborStation] = totalDistance;
                         path[neighborStation] = currentStation;
                     }
-    // Восстановление пути
+                }
-    const pathResult = [endStation];
+            }
-    let current = endStation;
+
             // Восстановление пути
-    while (current !== startStation) {
+            const pathResult = [endStation];
-      const prevStation = path[current];
+            let current = endStation;
-      pathResult.unshift(prevStation);
+
-      current = prevStation;
+            while (current !== startStation) {
                 const prevStation = path[current];
                 pathResult.unshift(prevStation);
-    return {
+                current = prevStation;
-      distance: distances[endStation],
+            }
-      path: pathResult,
+
-    };
+            paths.push({
-  }
+                distance: distances[endStation],
                 path: pathResult,
             });
         }
 
         // Сортировка путей по длине
         paths.sort((a, b) => a.distance - b.distance);
 
         return paths;
     }
 
     dijkstra(startStation, endStation) {
         const distances = {};
         const visited = {};
         const path = {};
 
-const result = metro.dijkstra("A", "D");
+        // Инициализация начальных расстояний и пути
         for (const station in this.stations) {
-console.log("Минимальное расстояние:", result.distance);
+            distances[station] = Infinity;
-console.log("Путь:", result.path.join(" -> "));
+            visited[station] = false;
             path[station] = null;
         }
 
         distances[startStation] = 0;
 
         // Шаги алгоритма Дейкстры
         while (true) {
             let currentStation = null;
             let currentDistance = Infinity;
 
             // Находим ближайшую непосещенную станцию
             for (const station in this.stations) {
                 if (!visited[station] && distances[station] < currentDistance) {
                     currentStation = station;
                     currentDistance = distances[station];
                 }
             }
 
             // Если все станции посещены, выходим из цикла
             if (currentStation === null) break;
 
             // Посещаем текущую станцию
             visited[currentStation] = true;
 
             // Обновляем расстояния до соседних станций
             for (const neighborStation in this.stations[currentStation]) {
                 const timeToNeighbor = this.stations[currentStation][neighborStation];
                 const totalDistance = distances[currentStation] + timeToNeighbor;
 
                 if (totalDistance < distances[neighborStation]) {
                     distances[neighborStation] = totalDistance;
                     path[neighborStation] = currentStation;
                 }
             }
         }
 
         // Восстановление пути
         const pathResult = [endStation];
         let current = endStation;
 
         while (current !== startStation) {
             const prevStation = path[current];
             pathResult.unshift(prevStation);
             current = prevStation;
         }
 
         return {
             distance: distances[endStation],
             path: pathResult,
         };
     }
 }
 
 
 // Пример использования
 const metro = new MetroGraph();
 
 metro.addStation("A");
 metro.addStation("B");
 metro.addStation("C");
 metro.addStation("D");
 
 metro.addConnection("A", "B", 5);
 metro.addConnection("B", "C", 3);
 metro.addConnection("C", "D", 7);
 metro.addConnection("A", "D", 20);
 
 const result = metro.dijkstraWithMultiplePaths("A", "D");
 
 console.log("Result:", result);