@hayro_o7/labyrinth 0.0.8 → 0.0.9

package/dist/algorithms/bidirectional-bfs.d.ts

@@ -1,6 +1,12 @@
-import type { GeneralGraph, BFSResult } from '../types';
+import type { GeneralGraph, BFSResult, BFSStep } from '../types';
 export declare function bidirectionalBFS(graph: GeneralGraph, startId: string, endId: string): BFSResult;
 export declare function findOptimalMultiGoalPath(graph: GeneralGraph, startId: string, goalIds: string[]): {
     optimalPath: string[];
     allPaths: Map<string, Map<string, string[]>>;
+    permutationSteps: BFSStep[];
+    testedPermutations: Array<{
+        path: string[];
+        length: number;
+        tour: string[];
+    }>;
 };

package/dist/algorithms/bidirectional-bfs.js

@@ -109,6 +109,8 @@ function permutations(arr) {
 }
 export function findOptimalMultiGoalPath(graph, startId, goalIds) {
     const allPaths = new Map();
+    const permutationSteps = [];
+    const testedPermutations = [];
     // Compute paths between all pairs
     const allNodes = [startId, ...goalIds];
     for (const from of allNodes) {
@@ -126,8 +128,10 @@ export function findOptimalMultiGoalPath(graph, startId, goalIds) {
     // Try all permutations to find shortest tour
     let shortestPath = [];
     let shortestLength = Infinity;
+    let bestPermIndex = -1;
     const goalPermutations = permutations(goalIds);
-    for (const perm of goalPermutations) {
+    for (let permIndex = 0; permIndex < goalPermutations.length; permIndex++) {
+        const perm = goalPermutations[permIndex];
         const tour = [startId, ...perm];
         let totalPath = [];
         let valid = true;
@@ -144,10 +148,38 @@ export function findOptimalMultiGoalPath(graph, startId, goalIds) {
                 totalPath = [...totalPath.slice(0, -1), ...segment];
             }
         }
-        if (valid && totalPath.length < shortestLength) {
-            shortestPath = totalPath;
-            shortestLength = totalPath.length;
+        if (valid) {
+            testedPermutations.push({ path: totalPath, length: totalPath.length, tour });
+            // Add visualization step for this permutation test
+            for (const nodeId of totalPath) {
+                permutationSteps.push({
+                    nodeId,
+                    type: 'permutation-test',
+                    permutationIndex: permIndex,
+                    permutationPath: totalPath,
+                    permutationLength: totalPath.length,
+                    isBest: false
+                });
+            }
+            if (totalPath.length < shortestLength) {
+                shortestPath = totalPath;
+                shortestLength = totalPath.length;
+                bestPermIndex = permIndex;
+            }
+        }
+    }
+    // Mark the best permutation
+    if (bestPermIndex >= 0) {
+        for (const nodeId of shortestPath) {
+            permutationSteps.push({
+                nodeId,
+                type: 'permutation-best',
+                permutationIndex: bestPermIndex,
+                permutationPath: shortestPath,
+                permutationLength: shortestLength,
+                isBest: true
+            });
         }
     }
-    return { optimalPath: shortestPath, allPaths };
+    return { optimalPath: shortestPath, allPaths, permutationSteps, testedPermutations };
 }

package/dist/components/GraphVisualizer.svelte

@@ -123,12 +123,42 @@
 		new Set(steps.slice(0, currentStepIndex).filter((s) => s.type === 'path').map((s) => s.nodeId))
 	);
 
+	const permutationTestNodes = $derived(
+		new Set(
+			steps
+				.slice(0, currentStepIndex)
+				.filter((s) => s.type === 'permutation-test')
+				.map((s) => s.nodeId)
+		)
+	);
+
+	const permutationBestNodes = $derived(
+		new Set(
+			steps
+				.slice(0, currentStepIndex)
+				.filter((s) => s.type === 'permutation-best')
+				.map((s) => s.nodeId)
+		)
+	);
+
+	const currentPermutationInfo = $derived(() => {
+		const currentStep = steps[currentStepIndex - 1];
+		if (currentStep?.type === 'permutation-test' || currentStep?.type === 'permutation-best') {
+			return {
+				index: currentStep.permutationIndex ?? 0,
+				length: currentStep.permutationLength ?? 0,
+				isBest: currentStep.isBest ?? false
+			};
+		}
+		return null;
+	});
+
 	function runAlgorithm() {
 		if (showMultiGoal && computedGoalNodes.length > 1) {
 			const result = findOptimalMultiGoalPath(graph, computedStartNode, computedGoalNodes);
 			optimalPath = result.optimalPath;
 			
-			// Generate visualization steps by running BFS for each segment
+			// First show BFS exploration for each pair
 			steps = [];
 			const tour = [computedStartNode, ...computedGoalNodes];
 			
@@ -136,6 +166,9 @@
 				const segmentResult = bidirectionalBFS(graph, tour[i], tour[i + 1]);
 				steps.push(...segmentResult.steps);
 			}
+			
+			// Then show permutation comparison phase
+			steps.push(...result.permutationSteps);
 		} else {
 			const result = bidirectionalBFS(graph, computedStartNode, computedGoalNodes[0]);
 			steps = result.steps;
@@ -198,6 +231,8 @@
 	function getNodeColor(nodeId: string): string {
 		if (nodeId === computedStartNode) return colorScheme.start;
 		if (computedGoalNodes.includes(nodeId)) return colorScheme.end;
+		if (permutationBestNodes.has(nodeId)) return '#10b981'; // Green for best permutation
+		if (permutationTestNodes.has(nodeId)) return '#fbbf24'; // Yellow for testing permutation
 		if (pathNodes.has(nodeId)) return colorScheme.path;
 		if (nodeId === intersectionNode) return '#a855f7';
 		if (nodeId === currentForwardNode) return colorScheme.current;
@@ -252,7 +287,20 @@
 </script>
 
 <div class="graph-container" style={cssVars}>
-	<svg width={svgWidth} height={svgHeight}>
+	{#if currentPermutationInfo()}
+		<div class="permutation-info">
+			{#if currentPermutationInfo()?.isBest}
+				<span class="font-mono text-sm font-bold" style="color: #10b981;">
+					✓ Best permutation found! Length: {currentPermutationInfo()?.length}
+				</span>
+			{:else}
+				<span class="font-mono text-sm">
+					Testing permutation #{(currentPermutationInfo()?.index ?? 0) + 1} - Length: {currentPermutationInfo()?.length}
+				</span>
+			{/if}
+		</div>
+	{/if}
+	<svg width={svgWidth} height={svgHeight} class="graph-svg">
 		<defs>
 			<marker
 				id="arrowhead"
@@ -315,4 +363,19 @@
 		gap: 1rem;
 		align-items: center;
 	}
+
+	.graph-svg {
+		background-color: white;
+		box-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1);
+		border: 2px solid #e5e7eb;
+		border-radius: 0.5rem;
+	}
+
+	.permutation-info {
+		padding: 0.75rem 1.5rem;
+		background-color: #f9fafb;
+		border: 2px solid #1f2937;
+		border-radius: 0.25rem;
+		text-align: center;
+	}
 </style>

package/dist/types.d.ts

@@ -72,9 +72,13 @@ export interface GeneralGraph {
 }
 export interface BFSStep {
     nodeId: string;
-    type: 'start-forward' | 'start-backward' | 'goal-forward' | 'goal-backward' | 'visited-forward' | 'visited-backward' | 'path' | 'current-forward' | 'current-backward' | 'intersection';
+    type: 'start-forward' | 'start-backward' | 'goal-forward' | 'goal-backward' | 'visited-forward' | 'visited-backward' | 'path' | 'current-forward' | 'current-backward' | 'intersection' | 'permutation-test' | 'permutation-best';
     side?: 'forward' | 'backward';
     level?: number;
+    permutationIndex?: number;
+    permutationPath?: string[];
+    permutationLength?: number;
+    isBest?: boolean;
 }
 export interface BFSResult {
     path: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@hayro_o7/labyrinth",
-	"version": "0.0.8",
+	"version": "0.0.9",
 	"type": "module",
 	"scripts": {
 		"dev": "vite dev",