Remove CFB/NASCAR/PGA and streamline to 8 supported sports
- Remove College Football, NASCAR, and PGA from scraper and app - Clean all data files (stadiums, games, pipeline reports) - Update Sport.swift enum and all UI components - Add sportstime.py CLI tool for pipeline management - Add DATA_SCRAPING.md documentation - Add WNBA/MLS/NWSL implementation documentation - Scraper now supports: NBA, MLB, NHL, NFL, WNBA, MLS, NWSL, CBB Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Trey t
@@ -2,7 +2,7 @@
|
||||
// GameDAGRouter.swift
|
||||
// SportsTime
|
||||
//
|
||||
// Time-expanded DAG + Beam Search algorithm for route finding.
|
||||
// DAG-based route finding with multi-dimensional diversity.
|
||||
//
|
||||
// Key insight: This is NOT "which subset of N games should I attend?"
|
||||
// This IS: "what time-respecting paths exist through a graph of games?"
|
||||
@@ -10,11 +10,14 @@
|
||||
// The algorithm:
|
||||
// 1. Bucket games by calendar day
|
||||
// 2. Build directed edges where time moves forward AND driving is feasible
|
||||
// 3. Beam search: keep top K paths at each depth
|
||||
// 4. Dominance pruning: discard inferior paths
|
||||
// 3. Generate routes via beam search
|
||||
// 4. Diversity pruning: ensure routes span full range of games, cities, miles, and days
|
||||
//
|
||||
// Complexity: O(days × beamWidth × avgNeighbors) ≈ 900 operations for 5-day, 78-game scenario
|
||||
// (vs 2^78 for naive subset enumeration)
|
||||
// The diversity system ensures users see:
|
||||
// - Short trips (2-3 cities) AND long trips (5+ cities)
|
||||
// - Quick trips (2-3 games) AND packed trips (5+ games)
|
||||
// - Low mileage AND high mileage options
|
||||
// - Short duration AND long duration trips
|
||||
//
|
||||
|
||||
import Foundation
|
||||
@@ -24,12 +27,11 @@ enum GameDAGRouter {
|
||||
|
||||
// MARK: - Configuration
|
||||
|
||||
/// Default beam width - how many partial routes to keep at each step
|
||||
/// Increased to ensure we preserve diverse route lengths (short and long trips)
|
||||
private static let defaultBeamWidth = 50
|
||||
/// Default beam width during expansion
|
||||
private static let defaultBeamWidth = 100
|
||||
|
||||
/// Maximum options to return (increased to provide more diverse trip lengths)
|
||||
private static let maxOptions = 50
|
||||
/// Maximum options to return (diverse sample)
|
||||
private static let maxOptions = 75
|
||||
|
||||
/// Buffer time after game ends before we can depart (hours)
|
||||
private static let gameEndBufferHours: Double = 3.0
|
||||
@@ -37,21 +39,55 @@ enum GameDAGRouter {
|
||||
/// Maximum days ahead to consider for next game (1 = next day only, 5 = allows multi-day drives)
|
||||
private static let maxDayLookahead = 5
|
||||
|
||||
// MARK: - Route Profile
|
||||
|
||||
/// Captures the key metrics of a route for diversity analysis
|
||||
private struct RouteProfile {
|
||||
let route: [Game]
|
||||
let gameCount: Int
|
||||
let cityCount: Int
|
||||
let totalMiles: Double
|
||||
let tripDays: Int
|
||||
|
||||
// Bucket indices for stratified sampling
|
||||
var gameBucket: Int { min(gameCount - 1, 5) } // 1, 2, 3, 4, 5, 6+
|
||||
var cityBucket: Int { min(cityCount - 1, 5) } // 1, 2, 3, 4, 5, 6+
|
||||
var milesBucket: Int {
|
||||
switch totalMiles {
|
||||
case ..<500: return 0 // Short
|
||||
case 500..<1000: return 1 // Medium
|
||||
case 1000..<2000: return 2 // Long
|
||||
case 2000..<3000: return 3 // Very long
|
||||
default: return 4 // Epic
|
||||
}
|
||||
}
|
||||
var daysBucket: Int { min(tripDays - 1, 6) } // 1-7+ days
|
||||
|
||||
/// Composite key for exact deduplication
|
||||
var uniqueKey: String {
|
||||
route.map { $0.id.uuidString }.joined(separator: "-")
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Public API
|
||||
|
||||
/// Finds best routes through the game graph using DAG + beam search.
|
||||
/// Finds routes through the game graph with multi-dimensional diversity.
|
||||
///
|
||||
/// This replaces the exponential GeographicRouteExplorer with a polynomial-time algorithm.
|
||||
/// Returns a curated sample that spans the full range of:
|
||||
/// - Number of games (2-game quickies to 6+ game marathons)
|
||||
/// - Number of cities (2-city to 6+ city routes)
|
||||
/// - Total miles (short drives to cross-country epics)
|
||||
/// - Trip duration (weekend getaways to week-long adventures)
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - games: All games to consider, in any order (will be sorted internally)
|
||||
/// - games: All games to consider
|
||||
/// - stadiums: Dictionary mapping stadium IDs to Stadium objects
|
||||
/// - constraints: Driving constraints (number of drivers, max hours per day)
|
||||
/// - anchorGameIds: Games that MUST appear in every valid route (for Scenario B)
|
||||
/// - constraints: Driving constraints (max hours per day)
|
||||
/// - anchorGameIds: Games that MUST appear in every valid route
|
||||
/// - allowRepeatCities: If false, each city can only appear once in a route
|
||||
/// - beamWidth: How many partial routes to keep at each depth (default 30)
|
||||
/// - beamWidth: How many partial routes to keep during expansion
|
||||
///
|
||||
/// - Returns: Array of valid game combinations, sorted by score (most games, least driving)
|
||||
/// - Returns: Array of diverse route options
|
||||
///
|
||||
static func findRoutes(
|
||||
games: [Game],
|
||||
@@ -65,21 +101,18 @@ enum GameDAGRouter {
|
||||
// Edge cases
|
||||
guard !games.isEmpty else { return [] }
|
||||
if games.count == 1 {
|
||||
// Single game - just return it if it satisfies anchors
|
||||
if anchorGameIds.isEmpty || anchorGameIds.contains(games[0].id) {
|
||||
return [games]
|
||||
}
|
||||
return []
|
||||
}
|
||||
if games.count == 2 {
|
||||
// Two games - check if both are reachable
|
||||
let sorted = games.sorted { $0.startTime < $1.startTime }
|
||||
if canTransition(from: sorted[0], to: sorted[1], stadiums: stadiums, constraints: constraints) {
|
||||
if anchorGameIds.isSubset(of: Set(sorted.map { $0.id })) {
|
||||
return [sorted]
|
||||
}
|
||||
}
|
||||
// Can't connect them - return individual games if they satisfy anchors
|
||||
if anchorGameIds.isEmpty {
|
||||
return [[sorted[0]], [sorted[1]]]
|
||||
}
|
||||
@@ -95,18 +128,9 @@ enum GameDAGRouter {
|
||||
|
||||
guard !sortedDays.isEmpty else { return [] }
|
||||
|
||||
|
||||
// Step 3: Initialize beam with first day's games
|
||||
// Step 3: Initialize beam with first few days' games as starting points
|
||||
var beam: [[Game]] = []
|
||||
if let firstDayGames = buckets[sortedDays[0]] {
|
||||
for game in firstDayGames {
|
||||
beam.append([game])
|
||||
}
|
||||
}
|
||||
|
||||
// Also include option to skip first day entirely and start later
|
||||
// (handled by having multiple starting points in beam)
|
||||
for dayIndex in sortedDays.dropFirst().prefix(maxDayLookahead - 1) {
|
||||
for dayIndex in sortedDays.prefix(maxDayLookahead) {
|
||||
if let dayGames = buckets[dayIndex] {
|
||||
for game in dayGames {
|
||||
beam.append([game])
|
||||
@@ -114,9 +138,8 @@ enum GameDAGRouter {
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Step 4: Expand beam day by day
|
||||
for (_, dayIndex) in sortedDays.dropFirst().enumerated() {
|
||||
for dayIndex in sortedDays.dropFirst() {
|
||||
let todaysGames = buckets[dayIndex] ?? []
|
||||
var nextBeam: [[Game]] = []
|
||||
|
||||
@@ -124,36 +147,34 @@ enum GameDAGRouter {
|
||||
guard let lastGame = path.last else { continue }
|
||||
let lastGameDay = dayIndexFor(lastGame.startTime, referenceDate: sortedGames[0].startTime)
|
||||
|
||||
// Only consider games on this day or within lookahead
|
||||
// Skip if this day is too far ahead for this route
|
||||
if dayIndex > lastGameDay + maxDayLookahead {
|
||||
// This path is too far behind, keep it as-is
|
||||
nextBeam.append(path)
|
||||
continue
|
||||
}
|
||||
|
||||
// Try adding each of today's games
|
||||
for candidate in todaysGames {
|
||||
// Check for repeat city violation during route building
|
||||
// Check for repeat city violation
|
||||
if !allowRepeatCities {
|
||||
let candidateCity = stadiums[candidate.stadiumId]?.city ?? ""
|
||||
let pathCities = Set(path.compactMap { stadiums[$0.stadiumId]?.city })
|
||||
if pathCities.contains(candidateCity) {
|
||||
continue // Skip - would violate allowRepeatCities
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
if canTransition(from: lastGame, to: candidate, stadiums: stadiums, constraints: constraints) {
|
||||
let newPath = path + [candidate]
|
||||
nextBeam.append(newPath)
|
||||
nextBeam.append(path + [candidate])
|
||||
}
|
||||
}
|
||||
|
||||
// Also keep the path without adding a game today (allows off-days)
|
||||
// Keep the path without adding a game today
|
||||
nextBeam.append(path)
|
||||
}
|
||||
|
||||
// Dominance pruning + beam truncation
|
||||
beam = pruneAndTruncate(nextBeam, beamWidth: beamWidth, stadiums: stadiums)
|
||||
// Diversity-aware pruning during expansion
|
||||
beam = diversityPrune(nextBeam, stadiums: stadiums, targetCount: beamWidth)
|
||||
}
|
||||
|
||||
// Step 5: Filter routes that contain all anchors
|
||||
@@ -162,21 +183,15 @@ enum GameDAGRouter {
|
||||
return anchorGameIds.isSubset(of: pathGameIds)
|
||||
}
|
||||
|
||||
// Step 6: Ensure geographic diversity in results
|
||||
// Group routes by their primary region (city with most games)
|
||||
// Then pick the best route from each region
|
||||
// Step 6: Final diversity selection
|
||||
let finalRoutes = selectDiverseRoutes(routesWithAnchors, stadiums: stadiums, maxCount: maxOptions)
|
||||
|
||||
print("🔍 DAG: Input games=\(games.count), beam final=\(beam.count), withAnchors=\(routesWithAnchors.count), final=\(finalRoutes.count)")
|
||||
if let best = finalRoutes.first {
|
||||
print("🔍 DAG: Best route has \(best.count) games")
|
||||
}
|
||||
print("🔍 DAG: Input games=\(games.count), beam=\(beam.count), withAnchors=\(routesWithAnchors.count), final=\(finalRoutes.count)")
|
||||
|
||||
return finalRoutes
|
||||
}
|
||||
|
||||
/// Compatibility wrapper that matches GeographicRouteExplorer's interface.
|
||||
/// This allows drop-in replacement in ScenarioAPlanner and ScenarioBPlanner.
|
||||
static func findAllSensibleRoutes(
|
||||
from games: [Game],
|
||||
stadiums: [UUID: Stadium],
|
||||
@@ -184,9 +199,7 @@ enum GameDAGRouter {
|
||||
allowRepeatCities: Bool = true,
|
||||
stopBuilder: ([Game], [UUID: Stadium]) -> [ItineraryStop]
|
||||
) -> [[Game]] {
|
||||
// Use default driving constraints
|
||||
let constraints = DrivingConstraints.default
|
||||
|
||||
return findRoutes(
|
||||
games: games,
|
||||
stadiums: stadiums,
|
||||
@@ -196,9 +209,236 @@ enum GameDAGRouter {
|
||||
)
|
||||
}
|
||||
|
||||
// MARK: - Multi-Dimensional Diversity Selection
|
||||
|
||||
/// Selects routes that maximize diversity across all dimensions.
|
||||
/// Uses stratified sampling to ensure representation of:
|
||||
/// - Short trips (2-3 games) AND long trips (5+ games)
|
||||
/// - Few cities (2-3) AND many cities (5+)
|
||||
/// - Low mileage AND high mileage
|
||||
/// - Short duration AND long duration
|
||||
private static func selectDiverseRoutes(
|
||||
_ routes: [[Game]],
|
||||
stadiums: [UUID: Stadium],
|
||||
maxCount: Int
|
||||
) -> [[Game]] {
|
||||
guard !routes.isEmpty else { return [] }
|
||||
|
||||
// Build profiles for all routes
|
||||
let profiles = routes.map { route in
|
||||
buildProfile(for: route, stadiums: stadiums)
|
||||
}
|
||||
|
||||
// Remove duplicates
|
||||
var uniqueProfiles: [RouteProfile] = []
|
||||
var seenKeys = Set<String>()
|
||||
for profile in profiles {
|
||||
if !seenKeys.contains(profile.uniqueKey) {
|
||||
seenKeys.insert(profile.uniqueKey)
|
||||
uniqueProfiles.append(profile)
|
||||
}
|
||||
}
|
||||
|
||||
// Stratified selection: ensure representation across all buckets
|
||||
var selected: [RouteProfile] = []
|
||||
var selectedKeys = Set<String>()
|
||||
|
||||
// Pass 1: Ensure at least one route per game count bucket (2, 3, 4, 5, 6+)
|
||||
let byGames = Dictionary(grouping: uniqueProfiles) { $0.gameBucket }
|
||||
for bucket in byGames.keys.sorted() {
|
||||
if selected.count >= maxCount { break }
|
||||
if let candidates = byGames[bucket]?.sorted(by: { $0.totalMiles < $1.totalMiles }) {
|
||||
if let best = candidates.first, !selectedKeys.contains(best.uniqueKey) {
|
||||
selected.append(best)
|
||||
selectedKeys.insert(best.uniqueKey)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Pass 2: Ensure at least one route per city count bucket (2, 3, 4, 5, 6+)
|
||||
let byCities = Dictionary(grouping: uniqueProfiles) { $0.cityBucket }
|
||||
for bucket in byCities.keys.sorted() {
|
||||
if selected.count >= maxCount { break }
|
||||
if let candidates = byCities[bucket]?.filter({ !selectedKeys.contains($0.uniqueKey) }) {
|
||||
if let best = candidates.sorted(by: { $0.totalMiles < $1.totalMiles }).first {
|
||||
selected.append(best)
|
||||
selectedKeys.insert(best.uniqueKey)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Pass 3: Ensure at least one route per mileage bucket
|
||||
let byMiles = Dictionary(grouping: uniqueProfiles) { $0.milesBucket }
|
||||
for bucket in byMiles.keys.sorted() {
|
||||
if selected.count >= maxCount { break }
|
||||
if let candidates = byMiles[bucket]?.filter({ !selectedKeys.contains($0.uniqueKey) }) {
|
||||
if let best = candidates.sorted(by: { $0.gameCount > $1.gameCount }).first {
|
||||
selected.append(best)
|
||||
selectedKeys.insert(best.uniqueKey)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Pass 4: Ensure at least one route per duration bucket
|
||||
let byDays = Dictionary(grouping: uniqueProfiles) { $0.daysBucket }
|
||||
for bucket in byDays.keys.sorted() {
|
||||
if selected.count >= maxCount { break }
|
||||
if let candidates = byDays[bucket]?.filter({ !selectedKeys.contains($0.uniqueKey) }) {
|
||||
if let best = candidates.sorted(by: { $0.gameCount > $1.gameCount }).first {
|
||||
selected.append(best)
|
||||
selectedKeys.insert(best.uniqueKey)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Pass 5: Fill remaining slots with diverse combinations
|
||||
// Create composite buckets for more granular diversity
|
||||
let remaining = uniqueProfiles.filter { !selectedKeys.contains($0.uniqueKey) }
|
||||
let byComposite = Dictionary(grouping: remaining) { profile in
|
||||
"\(profile.gameBucket)-\(profile.cityBucket)-\(profile.milesBucket)"
|
||||
}
|
||||
|
||||
// Round-robin from composite buckets
|
||||
var compositeKeys = Array(byComposite.keys).sorted()
|
||||
var indices: [String: Int] = [:]
|
||||
while selected.count < maxCount && !compositeKeys.isEmpty {
|
||||
var addedAny = false
|
||||
for key in compositeKeys {
|
||||
if selected.count >= maxCount { break }
|
||||
let idx = indices[key] ?? 0
|
||||
if let candidates = byComposite[key], idx < candidates.count {
|
||||
let profile = candidates[idx]
|
||||
if !selectedKeys.contains(profile.uniqueKey) {
|
||||
selected.append(profile)
|
||||
selectedKeys.insert(profile.uniqueKey)
|
||||
addedAny = true
|
||||
}
|
||||
indices[key] = idx + 1
|
||||
}
|
||||
}
|
||||
if !addedAny { break }
|
||||
}
|
||||
|
||||
// Pass 6: If still need more, add remaining sorted by efficiency
|
||||
if selected.count < maxCount {
|
||||
let stillRemaining = uniqueProfiles
|
||||
.filter { !selectedKeys.contains($0.uniqueKey) }
|
||||
.sorted { efficiency(for: $0) > efficiency(for: $1) }
|
||||
|
||||
for profile in stillRemaining.prefix(maxCount - selected.count) {
|
||||
selected.append(profile)
|
||||
}
|
||||
}
|
||||
|
||||
return selected.map { $0.route }
|
||||
}
|
||||
|
||||
/// Diversity-aware pruning during beam expansion.
|
||||
/// Keeps routes that span the diversity space rather than just high-scoring ones.
|
||||
private static func diversityPrune(
|
||||
_ paths: [[Game]],
|
||||
stadiums: [UUID: Stadium],
|
||||
targetCount: Int
|
||||
) -> [[Game]] {
|
||||
// Remove exact duplicates first
|
||||
var uniquePaths: [[Game]] = []
|
||||
var seen = Set<String>()
|
||||
for path in paths {
|
||||
let key = path.map { $0.id.uuidString }.joined(separator: "-")
|
||||
if !seen.contains(key) {
|
||||
seen.insert(key)
|
||||
uniquePaths.append(path)
|
||||
}
|
||||
}
|
||||
|
||||
guard uniquePaths.count > targetCount else { return uniquePaths }
|
||||
|
||||
// Build profiles
|
||||
let profiles = uniquePaths.map { buildProfile(for: $0, stadiums: stadiums) }
|
||||
|
||||
// Group by game count to ensure length diversity
|
||||
let byGames = Dictionary(grouping: profiles) { $0.gameBucket }
|
||||
let slotsPerBucket = max(2, targetCount / max(1, byGames.count))
|
||||
|
||||
var selected: [RouteProfile] = []
|
||||
var selectedKeys = Set<String>()
|
||||
|
||||
// Take from each game count bucket
|
||||
for bucket in byGames.keys.sorted() {
|
||||
if let candidates = byGames[bucket] {
|
||||
// Within bucket, prioritize geographic diversity
|
||||
let byCities = Dictionary(grouping: candidates) { $0.cityBucket }
|
||||
var bucketSelected = 0
|
||||
|
||||
for cityBucket in byCities.keys.sorted() {
|
||||
if bucketSelected >= slotsPerBucket { break }
|
||||
if let cityCandidates = byCities[cityBucket] {
|
||||
for profile in cityCandidates.prefix(2) {
|
||||
if !selectedKeys.contains(profile.uniqueKey) {
|
||||
selected.append(profile)
|
||||
selectedKeys.insert(profile.uniqueKey)
|
||||
bucketSelected += 1
|
||||
if bucketSelected >= slotsPerBucket { break }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Fill remaining with efficiency-sorted paths
|
||||
if selected.count < targetCount {
|
||||
let remaining = profiles.filter { !selectedKeys.contains($0.uniqueKey) }
|
||||
.sorted { efficiency(for: $0) > efficiency(for: $1) }
|
||||
|
||||
for profile in remaining.prefix(targetCount - selected.count) {
|
||||
selected.append(profile)
|
||||
}
|
||||
}
|
||||
|
||||
return selected.map { $0.route }
|
||||
}
|
||||
|
||||
/// Builds a profile for a route.
|
||||
private static func buildProfile(for route: [Game], stadiums: [UUID: Stadium]) -> RouteProfile {
|
||||
let gameCount = route.count
|
||||
let cities = Set(route.compactMap { stadiums[$0.stadiumId]?.city })
|
||||
let cityCount = cities.count
|
||||
|
||||
// Calculate total miles
|
||||
var totalMiles: Double = 0
|
||||
for i in 0..<(route.count - 1) {
|
||||
totalMiles += estimateDistanceMiles(from: route[i], to: route[i + 1], stadiums: stadiums)
|
||||
}
|
||||
|
||||
// Calculate trip duration in days
|
||||
let tripDays: Int
|
||||
if let firstGame = route.first, let lastGame = route.last {
|
||||
let calendar = Calendar.current
|
||||
let days = calendar.dateComponents([.day], from: firstGame.startTime, to: lastGame.startTime).day ?? 1
|
||||
tripDays = max(1, days + 1)
|
||||
} else {
|
||||
tripDays = 1
|
||||
}
|
||||
|
||||
return RouteProfile(
|
||||
route: route,
|
||||
gameCount: gameCount,
|
||||
cityCount: cityCount,
|
||||
totalMiles: totalMiles,
|
||||
tripDays: tripDays
|
||||
)
|
||||
}
|
||||
|
||||
/// Calculates efficiency score (games per hour of driving).
|
||||
private static func efficiency(for profile: RouteProfile) -> Double {
|
||||
let drivingHours = profile.totalMiles / 60.0 // 60 mph average
|
||||
guard drivingHours > 0 else { return Double(profile.gameCount) * 100 }
|
||||
return Double(profile.gameCount) / drivingHours
|
||||
}
|
||||
|
||||
// MARK: - Day Bucketing
|
||||
|
||||
/// Groups games by calendar day index (0 = first day of trip, 1 = second day, etc.)
|
||||
private static func bucketByDay(games: [Game]) -> [Int: [Game]] {
|
||||
guard let firstGame = games.first else { return [:] }
|
||||
let referenceDate = firstGame.startTime
|
||||
@@ -211,24 +451,15 @@ enum GameDAGRouter {
|
||||
return buckets
|
||||
}
|
||||
|
||||
/// Calculates the day index for a date relative to a reference date.
|
||||
private static func dayIndexFor(_ date: Date, referenceDate: Date) -> Int {
|
||||
let calendar = Calendar.current
|
||||
let refDay = calendar.startOfDay(for: referenceDate)
|
||||
let dateDay = calendar.startOfDay(for: date)
|
||||
let components = calendar.dateComponents([.day], from: refDay, to: dateDay)
|
||||
return components.day ?? 0
|
||||
return calendar.dateComponents([.day], from: refDay, to: dateDay).day ?? 0
|
||||
}
|
||||
|
||||
// MARK: - Transition Feasibility
|
||||
|
||||
/// Determines if we can travel from game A to game B.
|
||||
///
|
||||
/// Requirements:
|
||||
/// 1. B starts after A (time moves forward)
|
||||
/// 2. We have enough days between games to complete the drive
|
||||
/// 3. We can arrive at B before B starts
|
||||
///
|
||||
private static func canTransition(
|
||||
from: Game,
|
||||
to: Game,
|
||||
@@ -236,289 +467,62 @@ enum GameDAGRouter {
|
||||
constraints: DrivingConstraints
|
||||
) -> Bool {
|
||||
// Time must move forward
|
||||
guard to.startTime > from.startTime else {
|
||||
return false
|
||||
}
|
||||
guard to.startTime > from.startTime else { return false }
|
||||
|
||||
// Same stadium = always feasible (no driving needed)
|
||||
// Same stadium = always feasible
|
||||
if from.stadiumId == to.stadiumId { return true }
|
||||
|
||||
// Get stadiums
|
||||
guard let fromStadium = stadiums[from.stadiumId],
|
||||
let toStadium = stadiums[to.stadiumId] else {
|
||||
// Missing stadium info - can't calculate distance, reject to be safe
|
||||
print("⚠️ DAG: Stadium lookup failed - from:\(stadiums[from.stadiumId] != nil) to:\(stadiums[to.stadiumId] != nil)")
|
||||
return false
|
||||
}
|
||||
|
||||
let fromCoord = fromStadium.coordinate
|
||||
let toCoord = toStadium.coordinate
|
||||
|
||||
// Calculate driving time
|
||||
let distanceMiles = TravelEstimator.haversineDistanceMiles(
|
||||
from: CLLocationCoordinate2D(latitude: fromCoord.latitude, longitude: fromCoord.longitude),
|
||||
to: CLLocationCoordinate2D(latitude: toCoord.latitude, longitude: toCoord.longitude)
|
||||
from: CLLocationCoordinate2D(latitude: fromStadium.coordinate.latitude, longitude: fromStadium.coordinate.longitude),
|
||||
to: CLLocationCoordinate2D(latitude: toStadium.coordinate.latitude, longitude: toStadium.coordinate.longitude)
|
||||
) * 1.3 // Road routing factor
|
||||
|
||||
let drivingHours = distanceMiles / 60.0 // Average 60 mph
|
||||
let drivingHours = distanceMiles / 60.0
|
||||
|
||||
// Calculate available driving time between games
|
||||
// After game A ends (+ buffer), how much time until game B starts (- buffer)?
|
||||
// Calculate available time
|
||||
let departureTime = from.startTime.addingTimeInterval(gameEndBufferHours * 3600)
|
||||
let deadline = to.startTime.addingTimeInterval(-3600) // 1 hour buffer before game
|
||||
let availableSeconds = deadline.timeIntervalSince(departureTime)
|
||||
let availableHours = availableSeconds / 3600.0
|
||||
let availableHours = deadline.timeIntervalSince(departureTime) / 3600.0
|
||||
|
||||
// Calculate how many driving days we have
|
||||
// Each day can have maxDailyDrivingHours of driving
|
||||
// Calculate driving days available
|
||||
let calendar = Calendar.current
|
||||
let fromDay = calendar.startOfDay(for: from.startTime)
|
||||
let toDay = calendar.startOfDay(for: to.startTime)
|
||||
let daysBetween = calendar.dateComponents([.day], from: fromDay, to: toDay).day ?? 0
|
||||
let daysBetween = calendar.dateComponents(
|
||||
[.day],
|
||||
from: calendar.startOfDay(for: from.startTime),
|
||||
to: calendar.startOfDay(for: to.startTime)
|
||||
).day ?? 0
|
||||
|
||||
// Available driving hours = days between * max per day
|
||||
// (If games are same day, daysBetween = 0, but we might still have hours available)
|
||||
let maxDrivingHoursAvailable: Double
|
||||
if daysBetween == 0 {
|
||||
// Same day - only have hours between games
|
||||
maxDrivingHoursAvailable = max(0, availableHours)
|
||||
} else {
|
||||
// Multi-day - can drive each day
|
||||
maxDrivingHoursAvailable = Double(daysBetween) * constraints.maxDailyDrivingHours
|
||||
}
|
||||
let maxDrivingHoursAvailable = daysBetween == 0
|
||||
? max(0, availableHours)
|
||||
: Double(daysBetween) * constraints.maxDailyDrivingHours
|
||||
|
||||
// Check if we have enough driving time
|
||||
guard drivingHours <= maxDrivingHoursAvailable else {
|
||||
return false
|
||||
}
|
||||
|
||||
// Also verify we can arrive before game starts (sanity check)
|
||||
guard availableHours >= drivingHours else {
|
||||
return false
|
||||
}
|
||||
|
||||
return true
|
||||
return drivingHours <= maxDrivingHoursAvailable && drivingHours <= availableHours
|
||||
}
|
||||
|
||||
// MARK: - Geographic Diversity
|
||||
// MARK: - Distance Estimation
|
||||
|
||||
/// Selects diverse routes from the candidate set.
|
||||
/// Ensures diversity by BOTH route length (city count) AND primary city.
|
||||
/// This guarantees users see 2-city trips alongside 5+ city trips.
|
||||
private static func selectDiverseRoutes(
|
||||
_ routes: [[Game]],
|
||||
stadiums: [UUID: Stadium],
|
||||
maxCount: Int
|
||||
) -> [[Game]] {
|
||||
guard !routes.isEmpty else { return [] }
|
||||
|
||||
// Group routes by city count (route length)
|
||||
var routesByLength: [Int: [[Game]]] = [:]
|
||||
for route in routes {
|
||||
let cityCount = Set(route.compactMap { stadiums[$0.stadiumId]?.city }).count
|
||||
routesByLength[cityCount, default: []].append(route)
|
||||
}
|
||||
|
||||
// Sort routes within each length by score
|
||||
for (length, lengthRoutes) in routesByLength {
|
||||
routesByLength[length] = lengthRoutes.sorted {
|
||||
scorePath($0, stadiums: stadiums) > scorePath($1, stadiums: stadiums)
|
||||
}
|
||||
}
|
||||
|
||||
// Allocate slots to each length category
|
||||
// Goal: ensure at least 1 route per length category if available
|
||||
let sortedLengths = routesByLength.keys.sorted()
|
||||
let minPerLength = max(1, maxCount / max(1, sortedLengths.count))
|
||||
|
||||
var selectedRoutes: [[Game]] = []
|
||||
var selectedIds = Set<String>()
|
||||
|
||||
// First pass: take best route(s) from each length category
|
||||
for length in sortedLengths {
|
||||
if selectedRoutes.count >= maxCount { break }
|
||||
if let lengthRoutes = routesByLength[length] {
|
||||
let toTake = min(minPerLength, lengthRoutes.count, maxCount - selectedRoutes.count)
|
||||
for route in lengthRoutes.prefix(toTake) {
|
||||
let key = route.map { $0.id.uuidString }.joined(separator: "-")
|
||||
if !selectedIds.contains(key) {
|
||||
selectedRoutes.append(route)
|
||||
selectedIds.insert(key)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Second pass: fill remaining slots, prioritizing geographic diversity
|
||||
if selectedRoutes.count < maxCount {
|
||||
// Group remaining routes by primary city
|
||||
var remainingByCity: [String: [[Game]]] = [:]
|
||||
for route in routes {
|
||||
let key = route.map { $0.id.uuidString }.joined(separator: "-")
|
||||
if !selectedIds.contains(key) {
|
||||
let city = getPrimaryCity(for: route, stadiums: stadiums)
|
||||
remainingByCity[city, default: []].append(route)
|
||||
}
|
||||
}
|
||||
|
||||
// Sort by score within each city
|
||||
for (city, cityRoutes) in remainingByCity {
|
||||
remainingByCity[city] = cityRoutes.sorted {
|
||||
scorePath($0, stadiums: stadiums) > scorePath($1, stadiums: stadiums)
|
||||
}
|
||||
}
|
||||
|
||||
// Round-robin from each city
|
||||
let sortedCities = remainingByCity.keys.sorted { city1, city2 in
|
||||
let score1 = remainingByCity[city1]?.first.map { scorePath($0, stadiums: stadiums) } ?? 0
|
||||
let score2 = remainingByCity[city2]?.first.map { scorePath($0, stadiums: stadiums) } ?? 0
|
||||
return score1 > score2
|
||||
}
|
||||
|
||||
var cityIndices: [String: Int] = [:]
|
||||
while selectedRoutes.count < maxCount {
|
||||
var addedAny = false
|
||||
for city in sortedCities {
|
||||
if selectedRoutes.count >= maxCount { break }
|
||||
let idx = cityIndices[city] ?? 0
|
||||
if let cityRoutes = remainingByCity[city], idx < cityRoutes.count {
|
||||
let route = cityRoutes[idx]
|
||||
let key = route.map { $0.id.uuidString }.joined(separator: "-")
|
||||
if !selectedIds.contains(key) {
|
||||
selectedRoutes.append(route)
|
||||
selectedIds.insert(key)
|
||||
addedAny = true
|
||||
}
|
||||
cityIndices[city] = idx + 1
|
||||
}
|
||||
}
|
||||
if !addedAny { break }
|
||||
}
|
||||
}
|
||||
|
||||
return selectedRoutes
|
||||
}
|
||||
|
||||
/// Gets the primary city for a route (where most games are played).
|
||||
private static func getPrimaryCity(for route: [Game], stadiums: [UUID: Stadium]) -> String {
|
||||
var cityCounts: [String: Int] = [:]
|
||||
for game in route {
|
||||
let city = stadiums[game.stadiumId]?.city ?? "Unknown"
|
||||
cityCounts[city, default: 0] += 1
|
||||
}
|
||||
return cityCounts.max(by: { $0.value < $1.value })?.key ?? "Unknown"
|
||||
}
|
||||
|
||||
// MARK: - Scoring and Pruning
|
||||
|
||||
/// Scores a path. Higher = better.
|
||||
/// Prefers: more games, less driving, geographic coherence
|
||||
private static func scorePath(_ path: [Game], stadiums: [UUID: Stadium]) -> Double {
|
||||
// Handle empty or single-game paths
|
||||
guard path.count > 1 else {
|
||||
return Double(path.count) * 100.0
|
||||
}
|
||||
|
||||
let gameCount = Double(path.count)
|
||||
|
||||
// Calculate total driving
|
||||
var totalDriving: Double = 0
|
||||
for i in 0..<(path.count - 1) {
|
||||
totalDriving += estimateDrivingHours(from: path[i], to: path[i + 1], stadiums: stadiums)
|
||||
}
|
||||
|
||||
// Score: heavily weight game count, penalize driving
|
||||
return gameCount * 100.0 - totalDriving * 2.0
|
||||
}
|
||||
|
||||
/// Estimates driving hours between two games.
|
||||
private static func estimateDrivingHours(
|
||||
private static func estimateDistanceMiles(
|
||||
from: Game,
|
||||
to: Game,
|
||||
stadiums: [UUID: Stadium]
|
||||
) -> Double {
|
||||
// Same stadium = 0 driving
|
||||
if from.stadiumId == to.stadiumId { return 0 }
|
||||
|
||||
guard let fromStadium = stadiums[from.stadiumId],
|
||||
let toStadium = stadiums[to.stadiumId] else {
|
||||
return 5.0 // Fallback: assume 5 hours
|
||||
return 300 // Fallback estimate
|
||||
}
|
||||
|
||||
let fromCoord = fromStadium.coordinate
|
||||
let toCoord = toStadium.coordinate
|
||||
|
||||
let distanceMiles = TravelEstimator.haversineDistanceMiles(
|
||||
from: CLLocationCoordinate2D(latitude: fromCoord.latitude, longitude: fromCoord.longitude),
|
||||
to: CLLocationCoordinate2D(latitude: toCoord.latitude, longitude: toCoord.longitude)
|
||||
return TravelEstimator.haversineDistanceMiles(
|
||||
from: CLLocationCoordinate2D(latitude: fromStadium.coordinate.latitude, longitude: fromStadium.coordinate.longitude),
|
||||
to: CLLocationCoordinate2D(latitude: toStadium.coordinate.latitude, longitude: toStadium.coordinate.longitude)
|
||||
) * 1.3
|
||||
|
||||
return distanceMiles / 60.0
|
||||
}
|
||||
|
||||
/// Prunes dominated paths and truncates to beam width.
|
||||
/// Maintains diversity by both ending city AND route length to ensure short trips aren't eliminated.
|
||||
private static func pruneAndTruncate(
|
||||
_ paths: [[Game]],
|
||||
beamWidth: Int,
|
||||
stadiums: [UUID: Stadium]
|
||||
) -> [[Game]] {
|
||||
// Remove exact duplicates
|
||||
var uniquePaths: [[Game]] = []
|
||||
var seen = Set<String>()
|
||||
|
||||
for path in paths {
|
||||
let key = path.map { $0.id.uuidString }.joined(separator: "-")
|
||||
if !seen.contains(key) {
|
||||
seen.insert(key)
|
||||
uniquePaths.append(path)
|
||||
}
|
||||
}
|
||||
|
||||
// Group paths by unique city count (route length)
|
||||
// This ensures we keep short trips (2 cities) alongside long trips (5+ cities)
|
||||
var pathsByLength: [Int: [[Game]]] = [:]
|
||||
for path in uniquePaths {
|
||||
let cityCount = Set(path.compactMap { stadiums[$0.stadiumId]?.city }).count
|
||||
pathsByLength[cityCount, default: []].append(path)
|
||||
}
|
||||
|
||||
// Sort paths within each length group by score
|
||||
for (length, lengthPaths) in pathsByLength {
|
||||
pathsByLength[length] = lengthPaths.sorted {
|
||||
scorePath($0, stadiums: stadiums) > scorePath($1, stadiums: stadiums)
|
||||
}
|
||||
}
|
||||
|
||||
// Allocate beam slots proportionally to length groups, with minimum per group
|
||||
let sortedLengths = pathsByLength.keys.sorted()
|
||||
let minPerLength = max(2, beamWidth / max(1, sortedLengths.count))
|
||||
|
||||
var pruned: [[Game]] = []
|
||||
|
||||
// First pass: take minimum from each length group
|
||||
for length in sortedLengths {
|
||||
if let lengthPaths = pathsByLength[length] {
|
||||
let toTake = min(minPerLength, lengthPaths.count)
|
||||
pruned.append(contentsOf: lengthPaths.prefix(toTake))
|
||||
}
|
||||
}
|
||||
|
||||
// Second pass: fill remaining slots with best paths overall
|
||||
if pruned.count < beamWidth {
|
||||
let remaining = beamWidth - pruned.count
|
||||
let prunedIds = Set(pruned.map { $0.map { $0.id.uuidString }.joined(separator: "-") })
|
||||
|
||||
// Get all paths not yet added, sorted by score
|
||||
var additional = uniquePaths.filter {
|
||||
!prunedIds.contains($0.map { $0.id.uuidString }.joined(separator: "-"))
|
||||
}
|
||||
additional.sort { scorePath($0, stadiums: stadiums) > scorePath($1, stadiums: stadiums) }
|
||||
|
||||
pruned.append(contentsOf: additional.prefix(remaining))
|
||||
}
|
||||
|
||||
// Final truncation
|
||||
return Array(pruned.prefix(beamWidth))
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user