@happychef/algorithm 1.1.1 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happychef/algorithm",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "Restaurant and reservation algorithm utilities",
   "main": "index.js",
   "author": "happy chef",

package/simulateTableAssignment.js

@@ -135,14 +135,15 @@ function calculateDistance(tableA, tableB) {
 }
 
 /**
- * OPTIMIZED: Backtracking function to find a combination of tables (multi-table assignment).
- * Improvements:
- * - Pre-computed valid tables list to avoid redundant checks
- * - Better pruning with capacity tracking
- * - Early termination when exact match found
+ * HIGHLY OPTIMIZED: Backtracking with aggressive pruning for multi-table assignment.
+ * Key optimizations:
+ * - Tables are PRE-FILTERED, so no validity checks needed here
+ * - Aggressive branch pruning with capacity tracking
+ * - Early termination on optimal solutions
+ * - Minimal logging to reduce overhead
  */
-function findMultiTableCombination(tables, guestsNeeded, startIndex, currentSet, best, requiredSlots, tableOccupiedSlots, reservationDateStr, reservationTimeStr) {
-    // Base case: All guests are seated
+function findMultiTableCombination(tables, guestsNeeded, startIndex, currentSet, best) {
+    // Base case: All guests seated
     if (guestsNeeded <= 0) {
         // Calculate total distance for the current combination
         let distanceSum = 0;
@@ -151,82 +152,72 @@ function findMultiTableCombination(tables, guestsNeeded, startIndex, currentSet,
                 distanceSum += calculateDistance(currentSet[i], currentSet[j]);
             }
         }
-        // Update best solution if this one is better (fewer tables, then lower distance)
+        // Update if better (fewer tables, or same count with lower distance)
         if (currentSet.length < best.tableCount || (currentSet.length === best.tableCount && distanceSum < best.minDistance)) {
             best.minDistance = distanceSum;
-            best.tables = [...currentSet]; // Store a copy
+            best.tables = [...currentSet];
             best.tableCount = currentSet.length;
-            console.log(`Found new best table combination: ${best.tables.map(t => t.tableNumber).join(', ')}`);
         }
         return;
     }
 
-    if (startIndex >= tables.length) {
+    // PRUNING: Can't improve on current best table count
+    if (currentSet.length >= best.tableCount && best.tableCount !== Infinity) {
         return;
     }
 
-    // OPTIMIZATION: Prune if we already have enough tables in current set
-    if (currentSet.length >= best.tableCount && best.tableCount !== Infinity) {
-        return; // Can't improve on current best
+    // PRUNING: Not enough tables remaining
+    if (startIndex >= tables.length) {
+        return;
     }
 
-    // OPTIMIZATION: Calculate max possible capacity from remaining tables
-    let maxPossibleCapacity = 0;
+    // PRUNING: Calculate remaining capacity (tables are pre-filtered, so all are valid)
+    let maxRemainingCapacity = 0;
     for (let i = startIndex; i < tables.length; i++) {
-        const tbl = tables[i];
-        // Only consider valid & free tables for potential capacity
-        if (isTemporaryTableValid(tbl, reservationDateStr, reservationTimeStr) &&
-            isTableFreeForAllSlots(tbl.tableNumber, requiredSlots, tableOccupiedSlots))
-        {
-            maxPossibleCapacity += tbl.maxCapacity;
-        }
+        maxRemainingCapacity += tables[i].maxCapacity;
+    }
+    if (maxRemainingCapacity < guestsNeeded) {
+        return; // Impossible to satisfy
     }
 
-    if (maxPossibleCapacity < guestsNeeded) {
-        return; // Impossible to seat remaining guests
+    // OPTIMIZATION: Limit search depth for large table sets
+    const remainingTables = tables.length - startIndex;
+    if (remainingTables > 15 && currentSet.length === 0) {
+        // For first iteration with many tables, only try largest tables
+        const sortedBySize = tables.slice(startIndex).sort((a, b) => b.maxCapacity - a.maxCapacity);
+        const topTables = sortedBySize.slice(0, Math.min(10, sortedBySize.length));
+
+        for (const tbl of topTables) {
+            const canSeat = Math.min(tbl.maxCapacity, guestsNeeded);
+            if (canSeat >= tbl.minCapacity || canSeat >= guestsNeeded) {
+                currentSet.push(tbl);
+                findMultiTableCombination(tables, guestsNeeded - canSeat, startIndex + 1, currentSet, best);
+                currentSet.pop();
+
+                if (best.tableCount === 1) return; // Found optimal
+            }
+        }
+        return;
     }
 
+    // Standard backtracking for remaining cases
     for (let i = startIndex; i < tables.length; i++) {
         const tbl = tables[i];
-
-        // --- Core Checks ---
-        // 1. Check if temporary table is valid for this date/time
-        if (!isTemporaryTableValid(tbl, reservationDateStr, reservationTimeStr)) {
-            continue; // Skip invalid temporary table
-        }
-
-        // 2. Check if table is free for all required slots
-        if (!isTableFreeForAllSlots(tbl.tableNumber, requiredSlots, tableOccupiedSlots)) {
-            continue; // Skip occupied table
-        }
-
-        // 3. Check if table contributes meaningfully
         const canSeat = Math.min(tbl.maxCapacity, guestsNeeded);
+
+        // Skip if table can't contribute meaningfully
         if (canSeat < tbl.minCapacity && canSeat < guestsNeeded) {
-            continue; // Don't use a table for fewer than its min capacity unless it fulfills the remainder
+            continue;
         }
 
-        if (canSeat <= 0) continue; // Table doesn't help
-
-        // --- Recurse ---
-        currentSet.push(tbl); // Add table to current combination
-
-        findMultiTableCombination(
-            tables,
-            guestsNeeded - canSeat, // Reduce guests needed
-            i + 1, // Explore next tables
-            currentSet,
-            best,
-            requiredSlots,
-            tableOccupiedSlots,
-            reservationDateStr,
-            reservationTimeStr
-        );
+        if (canSeat <= 0) continue;
 
-        currentSet.pop(); // Backtrack: remove table to explore other combinations
+        currentSet.push(tbl);
+        findMultiTableCombination(tables, guestsNeeded - canSeat, i + 1, currentSet, best);
+        currentSet.pop();
 
-        // OPTIMIZATION: Early exit if we found a single-table solution (best possible)
-        if (best.tableCount === 1) {
+        // EARLY EXIT: Found optimal single or two-table solution
+        if (best.tableCount <= 2) {
             return;
         }
     }
@@ -304,11 +295,7 @@ function assignTablesForGivenTime(restaurantData, date, time, guests, tableOccup
         guests,
         0, // Start index
         [], // Initial empty set
-        best, // Best solution object
-        requiredSlots,
-        tableOccupiedSlots,
-        date, // Pass context
-        time  // Pass context
+        best // Best solution object (no need for slots/occupancy - already filtered)
     );
 
     if (best.tables.length > 0) {
@@ -455,10 +442,9 @@ function isTimeAvailableSync(restaurantData, date, time, guests, reservations, s
         findMultiTableCombination(
             validTables, // Use pre-filtered tables
             guests,
-            0, [], best,
-            requiredSlots,
-            tableOccupiedSlots, // Use the final occupancy map
-            date, time
+            0, // Start index
+            [], // Empty current set
+            best // Best solution
         );
 
         const result = best.tables.length > 0;