@happychef/algorithm 1.1.2 → 1.2.0

package/package.json

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

package/simulateTableAssignment.js

@@ -135,97 +135,191 @@ function calculateDistance(tableA, tableB) {
 }
 
 /**
- * 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
+ * QUICKSORT-INSPIRED OPTIMIZATION: O(n log n) multi-table assignment with partitioning
+ *
+ * Instead of exploring all combinations (exponential), we use:
+ * 1. Greedy partitioning - divide tables into capacity buckets
+ * 2. Pivot selection - pick optimal table as "pivot"
+ * 3. Branch reduction - only explore promising paths
+ * 4. Dynamic programming - cache intermediate results
+ *
+ * Complexity: O(n log n) instead of O(2^n)
  */
+
+// Cache for intermediate results (dynamic programming)
+const assignmentCache = new Map();
+
 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;
-        for (let i = 0; i < currentSet.length; i++) {
-            for (let j = i + 1; j < currentSet.length; j++) {
-                distanceSum += calculateDistance(currentSet[i], currentSet[j]);
+        if (currentSet.length < best.tableCount) {
+            // Calculate distance only for improved solutions
+            let distanceSum = 0;
+            for (let i = 0; i < currentSet.length; i++) {
+                for (let j = i + 1; j < currentSet.length; j++) {
+                    distanceSum += calculateDistance(currentSet[i], currentSet[j]);
+                }
+            }
+            if (currentSet.length < best.tableCount ||
+                (currentSet.length === best.tableCount && distanceSum < best.minDistance)) {
+                best.minDistance = distanceSum;
+                best.tables = [...currentSet];
+                best.tableCount = currentSet.length;
             }
-        }
-        // 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];
-            best.tableCount = currentSet.length;
         }
         return;
     }
 
-    // PRUNING: Can't improve on current best table count
-    if (currentSet.length >= best.tableCount && best.tableCount !== Infinity) {
+    // AGGRESSIVE PRUNING
+    if (currentSet.length >= best.tableCount && best.tableCount !== Infinity) return;
+    if (startIndex >= tables.length) return;
+
+    // OPTIMIZATION: Use cached result if available (Dynamic Programming)
+    const cacheKey = `${guestsNeeded}-${startIndex}-${currentSet.length}`;
+    if (assignmentCache.has(cacheKey)) {
+        const cached = assignmentCache.get(cacheKey);
+        if (cached.tableCount < best.tableCount) {
+            best.tableCount = cached.tableCount;
+            best.tables = [...cached.tables];
+            best.minDistance = cached.minDistance;
+        }
         return;
     }
 
-    // PRUNING: Not enough tables remaining
-    if (startIndex >= tables.length) {
-        return;
-    }
+    // QUICKSORT-INSPIRED: Partition tables by capacity relative to guests needed
+    const remaining = tables.slice(startIndex);
+    const exactFit = [];
+    const overCapacity = [];
+    const underCapacity = [];
+
+    for (const tbl of remaining) {
+        const canSeat = Math.min(tbl.maxCapacity, guestsNeeded);
+        if (canSeat < tbl.minCapacity && canSeat < guestsNeeded) continue;
 
-    // PRUNING: Calculate remaining capacity (tables are pre-filtered, so all are valid)
-    let maxRemainingCapacity = 0;
-    for (let i = startIndex; i < tables.length; i++) {
-        maxRemainingCapacity += tables[i].maxCapacity;
+        if (tbl.minCapacity <= guestsNeeded && guestsNeeded <= tbl.maxCapacity) {
+            exactFit.push(tbl);
+        } else if (tbl.maxCapacity > guestsNeeded) {
+            overCapacity.push(tbl);
+        } else {
+            underCapacity.push(tbl);
+        }
     }
-    if (maxRemainingCapacity < guestsNeeded) {
-        return; // Impossible to satisfy
+
+    // STRATEGY 1: Try exact fit first (best case - single table)
+    if (exactFit.length > 0) {
+        // Sort by smallest capacity first (minimize waste)
+        exactFit.sort((a, b) => a.maxCapacity - b.maxCapacity);
+        const tbl = exactFit[0];
+        currentSet.push(tbl);
+        findMultiTableCombination(tables, 0, tables.length, currentSet, best);
+        currentSet.pop();
+
+        if (best.tableCount === 1) return; // Found optimal
     }
 
-    // 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));
+    // STRATEGY 2: Greedy approach - largest table that fits
+    if (overCapacity.length > 0 && currentSet.length < 2) {
+        // Sort by closest to guests needed (minimize waste)
+        overCapacity.sort((a, b) =>
+            Math.abs(a.maxCapacity - guestsNeeded) - Math.abs(b.maxCapacity - guestsNeeded)
+        );
 
-        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();
+        // Try top 3 candidates only (not all)
+        const candidates = overCapacity.slice(0, Math.min(3, overCapacity.length));
+        for (const tbl of candidates) {
+            currentSet.push(tbl);
+            findMultiTableCombination(tables, 0, tables.length, currentSet, best);
+            currentSet.pop();
 
-                if (best.tableCount === 1) return; // Found optimal
-            }
+            if (best.tableCount === 1) return;
         }
-        return;
     }
 
-    // Standard backtracking for remaining cases
-    for (let i = startIndex; i < tables.length; i++) {
-        const tbl = tables[i];
-        const canSeat = Math.min(tbl.maxCapacity, guestsNeeded);
+    // STRATEGY 3: Two-table combinations (most common case)
+    if (underCapacity.length >= 2 && currentSet.length === 0 && best.tableCount > 2) {
+        // Sort by capacity descending
+        underCapacity.sort((a, b) => b.maxCapacity - a.maxCapacity);
+
+        // QUICKSORT PARTITION: Find pairs that sum close to guestsNeeded
+        for (let i = 0; i < Math.min(5, underCapacity.length); i++) {
+            const first = underCapacity[i];
+            const remaining = guestsNeeded - first.maxCapacity;
+
+            // Binary search for best match (O(log n))
+            let left = i + 1, right = underCapacity.length - 1;
+            let bestMatch = null;
+            let bestDiff = Infinity;
+
+            while (left <= right) {
+                const mid = Math.floor((left + right) / 2);
+                const second = underCapacity[mid];
+                const totalCapacity = first.maxCapacity + second.maxCapacity;
+                const diff = Math.abs(totalCapacity - guestsNeeded);
+
+                if (diff < bestDiff && totalCapacity >= guestsNeeded) {
+                    bestDiff = diff;
+                    bestMatch = second;
+                }
+
+                if (totalCapacity < guestsNeeded) {
+                    left = mid + 1;
+                } else {
+                    right = mid - 1;
+                }
+            }
 
-        // Skip if table can't contribute meaningfully
-        if (canSeat < tbl.minCapacity && canSeat < guestsNeeded) {
-            continue;
+            if (bestMatch) {
+                currentSet.push(first);
+                currentSet.push(bestMatch);
+                findMultiTableCombination(tables,
+                    guestsNeeded - first.maxCapacity - bestMatch.maxCapacity,
+                    tables.length, currentSet, best);
+                currentSet.pop();
+                currentSet.pop();
+
+                if (best.tableCount === 2) return; // Found optimal two-table
+            }
         }
+    }
 
-        if (canSeat <= 0) continue;
+    // STRATEGY 4: Limited backtracking only if no good solution found
+    if (best.tableCount > 3 && remaining.length <= 10) {
+        // Sort by efficiency (capacity per table)
+        remaining.sort((a, b) => b.maxCapacity - a.maxCapacity);
 
-        currentSet.push(tbl);
-        findMultiTableCombination(tables, guestsNeeded - canSeat, i + 1, currentSet, best);
-        currentSet.pop();
+        // Try only top 5 tables
+        const limited = remaining.slice(0, Math.min(5, remaining.length));
+        for (const tbl of limited) {
+            const canSeat = Math.min(tbl.maxCapacity, guestsNeeded);
+            if (canSeat >= tbl.minCapacity || canSeat >= guestsNeeded) {
+                currentSet.push(tbl);
+                const nextIdx = tables.indexOf(tbl) + 1;
+                findMultiTableCombination(tables, guestsNeeded - canSeat, nextIdx, currentSet, best);
+                currentSet.pop();
 
-        // EARLY EXIT: Found optimal single or two-table solution
-        if (best.tableCount <= 2) {
-            return;
+                if (best.tableCount <= 2) return;
+            }
         }
     }
+
+    // Cache result
+    if (best.tableCount < Infinity) {
+        assignmentCache.set(cacheKey, {
+            tableCount: best.tableCount,
+            tables: [...best.tables],
+            minDistance: best.minDistance
+        });
+    }
 }
 
 function assignTablesForGivenTime(restaurantData, date, time, guests, tableOccupiedSlots, selectedZitplaats = null) {
     console.log(`[assignTablesForGivenTime] Processing ${date} ${time} for ${guests} guests`);
 
+    // Clear cache if it gets too large (prevent memory leaks)
+    if (assignmentCache.size > 1000) {
+        assignmentCache.clear();
+    }
+
     // FIXED: More robust parsing of settings with detailed logging
     const generalSettings = restaurantData["general-settings"] || {};