I'm trying to write an algorithm that takes a list of events (in this case, screenings of movies - each movie usually has more than one screening, although that's not always the case) and returns the best possible combination of events, i.e. the one that sacrifices the least amount of movies.
I came up with this algorithm which I applied manually, but I'm trying to turn it into code and having some trouble. What I did (manually) was go screening by screening, checking whether it had conflicts with any other screening. If it did, it would resolve the conflicts (let's say it's a conflict between the first screenings of Movie A and Movie B) by choosing one of the two conflicting movies* (Movie A), deleting all other screenings for Movie A, and deleting that screening of Movie B. After doing that, it would look for another screening of Movie B, check whether it had any conflicts, and repeat the process.
* Usually the one I was currently checking, but some criteria could affect the decision, e.g. if one of the two conflicting movies had a free (conflict-less) screening somewhere else, I would just choose that one and resolve the conflict that way. Conversely, if one of the two movies had no other screenings, I would choose that one.
Eventually this "branch" would end up arriving at a free (conflict-less) screening, which would mean the entire branch was solved (i.e. all of the movies involved could be watched without sacrificing any others), or it would arrive at a stalemate, which would mean that this combination of decisions did not lead to a perfect solution. In this case, one would go back up a level of recursion (i.e. go back one decision) and try choosing the other screening. If that didn't work, go back up another level and try again. If there was no combination of decisions in that branch that led to a solved branch, a decision had to be made by the human to sacrifice one of the movies that was causing the issue.
That's pretty much what I'm trying to code, and I wrote an attempt at it in a very stream-of-consciousness way just trying to get it out quickly cause I was excited, not thinking far ahead and just fixing issues as they came up. It worked for the movie festival I was trying it on, which was somewhat small (no more than 4 screenings at the same time), but crashed when I tried it on a larger one (6+ screenings at the same time sometimes). It exceeds the maximum stack size, probably because of a problem in the code although I'm not sure if it might just be running correctly and just getting into those levels of recursion. On this note, not sure whether this would be better solved with a while loop instead of recursively.
Yesterday I decided to scrap the algorithm I wrote and start from scratch in a better planned manner, and found the main 2 issues I see looking into the future are:
- The ability for the algorithm to "go back" and switch its previous decision when a branch failed. This is a core mechanic of the algorithm but I'm struggling to think of a good way to code it. In my previous one I implemented a "checkpoint" system where, if a branch failed, it would revert back to the last checkpoint and continue on from there, and if it succeeded, it would mark that one as the new checkpoint. But that only worked top-level, and not for "internal" decisions.
- The fact that most schedules will have more than one solution. If the solution is perfect (i.e. no movies sacrificed), then the issue is very minor in that either way you won't be missing any movies, and at most you'll be deprived of choosing between a few screenings of the same movies. But if there is no perfect solution, now the choice might be between having to decide between 2 movies that you really wanna watch, and between 2 movies that you don't care about that much. This means that the algorithm would need to go over every single possible combination of screenings to find the best possible one(s), and if there's no perfect solution it would show you the different possibilities. But this would be brute forcing the problem which (unless strictly necessary) is not really what I'm looking for.
I'd appreciate any help or guidance in the matter. For reference, I'm writing this in Typescript + React + Next.js, but I think this is a more general CS question so again, any help is appreciated.
The current algorithm as well as mock data can be found here: https://jsfiddle.net/procz/82n3jxLb/
const findBestSchedule = (
screeningData: IScreening[],
movies: IMovie[]
): IScreening[] => {
const debugLog = (type: string, args) => {
if (!DEBUG_LOG) return;
if (type === "process") {
return console.log(
`processing ${findMovie(
movies,
args.screening
).name.toUpperCase()} ${args.screening.date.getDate()} ${args.screening.date.getHours()}hs - called from ${
args.calledFrom
}, currentArray:`,
args.screenings
);
}
if (type === "conflict") {
return console.log(
`conflict between ${findMovie(
args.movies,
args.screening1
).name.toUpperCase()} ${args.screening1.date.getDate()} ${args.screening1.date.getHours()}hs and ${findMovie(
movies,
args.screening2
).name.toUpperCase()} ${args.screening2.date.getDate()} ${args.screening2.date.getHours()}hs`
);
}
if (type === "free") {
return console.log(
`${findMovie(
args.movies,
args.screening
).name.toUpperCase()} ${args.screening.date.getDate()} ${args.screening.date.getHours()}hs is free, deleting all other ${findMovie(
args.movies,
args.screening
).name.toUpperCase()}`
);
}
if (type === "recursion") {
return console.log(args.recursionLevel, args.array);
}
if (type === "unsolvable") {
return console.log(
`unsolvable conflict between ${findMovie(
args.movies,
args.screening1
).name.toUpperCase()} and ${findMovie(
args.movies,
args.screening2
).name.toUpperCase()}, backtracking`
);
}
if (type === "decision") {
return console.log(
`recursion level: ${args.recursionLevel} - choosing ${findMovie(
args.movies,
args.screening1
).name.toUpperCase()} ${args.screening1.date.getDate()} ${args.screening1.date.getHours()}hs, deleting ${findMovie(
args.movies,
args.screening2
).name.toUpperCase()} ${args.screening2.date.getDate()} ${args.screening2.date.getHours()}hs, deleting all other ${findMovie(
args.movies,
args.screening1
).name.toUpperCase()}`
);
}
if (type === "noConflict") {
return console.log(
`no conflicts found for ${findMovie(
args.movies,
args.screening
).name.toUpperCase()} ${args.screening.date.getDate()} ${args.screening.date.getHours()}hs, deleting all other ${findMovie(
args.movies,
args.screening
).name.toUpperCase()}`
);
}
};
const sortedScreenings = [...screeningData].sort(
(a, b) => b.date.getTime() - a.date.getTime()
);
let latestScreeningArray = sortedScreenings;
let recursionLevel = 0;
let lastSafeArray = latestScreeningArray;
let lastSafeRecursionLevel = recursionLevel;
const processScreening = (
screenings: IScreening[],
screening: IScreening,
calledFrom ? : string
): boolean => {
debugLog("process", {
screening,
calledFrom,
screenings
});
const findConflictingScreenings = (
screenings: IScreening[],
screening: IScreening
): IScreening[] => {
if (!screenings) return [];
return [...screenings].filter(
(otherScreening) =>
screening.id !== otherScreening ? .id &&
screeningsOverlap(screening, otherScreening, movies)
);
};
const conflictingScreenings = findConflictingScreenings(
screenings,
screening
);
if (conflictingScreenings.length) {
const resolveConflict = (
screening: IScreening,
otherScreening: IScreening
): boolean => {
debugLog("conflict", {
screening1: screening,
screening2: otherScreening,
movies,
});
const findNextScreenings = (
screenings: IScreening[],
screening: IScreening
): IScreening[] => {
return [...screenings]
.reverse()
.filter(
(currentScreening) =>
currentScreening.id !== screening.id &&
findMovie(movies, currentScreening).id ===
findMovie(movies, screening).id
);
};
const findFreeScreening = (
screenings: IScreening[],
screening: IScreening
): IScreening => {
return findNextScreenings(screenings, screening).find(
(nextScreening) =>
!findConflictingScreenings(screenings, nextScreening).length
);
};
const freeOtherScreening = findFreeScreening(
latestScreeningArray,
otherScreening
);
const freeScreening = findFreeScreening(
latestScreeningArray,
screening
);
if (freeOtherScreening || freeScreening) {
/* FREE SCREENING */
debugLog("free", {
screening: freeOtherScreening || freeScreening,
movies,
});
latestScreeningArray = deleteAllOtherScreenings(
latestScreeningArray,
freeOtherScreening || freeScreening,
movies
);
return true;
} else {
/* NO FREE SCREENINGS */
const decideAndMoveToNextStep = (
screenings: IScreening[],
screening1: IScreening,
screening2: IScreening
): boolean => {
latestScreeningArray = removeScreening(
deleteAllOtherScreenings(screenings, screening1, movies),
screening2
);
debugLog("recursion", {
recursionLevel,
array: latestScreeningArray,
});
recursionLevel++;
const nextStepOfBranchIsSolvable = processScreening(
latestScreeningArray,
findNextScreenings(screenings, screening2)[0],
`decideAndMoveToNextStep`
);
if (!nextStepOfBranchIsSolvable) {
debugLog("unsolvable", {
movies,
screening1,
screening2
});
latestScreeningArray = screenings;
}
return nextStepOfBranchIsSolvable;
};
const nextScreeningOfOther = findNextScreenings(
latestScreeningArray,
otherScreening
)[0];
if (nextScreeningOfOther) {
debugLog("decision", {
recursionLevel,
movies,
screening1: screening,
screening2: otherScreening,
});
return decideAndMoveToNextStep(
latestScreeningArray,
screening,
otherScreening
);
} else {
const nextScreening = findNextScreenings(
latestScreeningArray,
screening
)[0];
if (nextScreening) {
debugLog("decision", {
recursionLevel,
movies,
screening1: otherScreening,
screening2: screening,
});
return decideAndMoveToNextStep(
latestScreeningArray,
otherScreening,
screening
);
} else {
debugLog("unsolvable", {
movies,
screening1: screening,
screening2: otherScreening,
});
return false;
}
}
}
};
for (let i = conflictingScreenings.length - 1; i >= 0; i--) {
const branchResolved = resolveConflict(
screening,
[...conflictingScreenings].reverse()[i]
);
if (!branchResolved) {
latestScreeningArray = lastSafeArray;
break;
}
}
debugLog("noConflicts", {
movies,
screening
});
debugLog("recursion", {
recursionLevel,
array: latestScreeningArray
});
if (recursionLevel > 0) {
recursionLevel--;
}
return true;
} else {
const updatedScreenings = deleteAllOtherScreenings(
screenings,
screening,
movies
);
latestScreeningArray = updatedScreenings;
if (recursionLevel > 0) {
recursionLevel--;
}
return false;
}
};
for (let i = latestScreeningArray.length - 1; i >= 0; i--) {
if (!!latestScreeningArray[i]) {
lastSafeArray = latestScreeningArray;
lastSafeRecursionLevel = recursionLevel;
processScreening(
latestScreeningArray,
latestScreeningArray[i],
"overarching"
);
}
}
return latestScreeningArray;
};
