127 lines
3.5 KiB
JavaScript
127 lines
3.5 KiB
JavaScript
const fs = require('fs/promises');
|
|
|
|
const sum = (arr) => arr.reduce((total, num) => total+num, 0);
|
|
const arrayOfLength = n => Array.from(Array(n).keys()).map(() => {});
|
|
|
|
const main = async () => {
|
|
const input = (await fs.readFile("./input.txt", 'utf8')).split("\n").map(x => x.split("").map(x => x.charCodeAt(0)));
|
|
const start = input.reduce((found, row, i) => {
|
|
if(found) return found;
|
|
|
|
const j = row.indexOf(83);
|
|
if(j !== -1) {
|
|
return [j, i];
|
|
}
|
|
|
|
}, undefined);
|
|
|
|
let minPath = Infinity;
|
|
const maxY = input.length;
|
|
const maxX = input[0].length;
|
|
|
|
//Wrapped most of the context into a function that could be called over and
|
|
//over to try again from differnt points
|
|
const exploreMapFrom = (start) => {
|
|
|
|
const visited = arrayOfLength(maxY).map(_ => arrayOfLength(maxX));
|
|
const shortestPaths = arrayOfLength(maxY).map(_ => arrayOfLength(maxX).map(_ => Infinity));
|
|
|
|
|
|
// Added this print function so I could watch an algorithm to see how
|
|
// quickly it was progressing. The final algorithm ended up being so quick
|
|
// that this can't even render it properly
|
|
|
|
let nextPrint = 0;
|
|
|
|
const print = () => {
|
|
if(Date.now() > nextPrint) {
|
|
process.stdout.write('\u001b[2J');
|
|
process.stdout.write('\u001b[;H');
|
|
console.log(visited.map(row => row.map(x => x ? "X": ".").join("")).join("\n"));
|
|
console.log("\n\n\n")
|
|
console.log("Paths found: ", minPath);
|
|
nextPrint = Date.now() + 10;
|
|
}
|
|
};
|
|
|
|
const canVisit = ([fx,fy], [tx,ty]) => {
|
|
// Don't go off the map
|
|
if(Math.min(tx, ty) < 0 || tx >= maxX || ty >= maxY) {
|
|
return false;
|
|
}
|
|
|
|
// Don't visit squares we've already visited.
|
|
if(visited[ty][tx]) {
|
|
return false;
|
|
}
|
|
|
|
// S = a and E = z
|
|
let fz = input[fy][fx] === 83 ? 97 : input[fy][fx];
|
|
let tz = input[ty][tx] === 69 ? 122 : input[ty][tx];
|
|
|
|
// No climbing gear allowed
|
|
return tz <= fz + 1;
|
|
}
|
|
|
|
const explore = (visited, loc, stepCount) => {
|
|
const [x, y] = loc;
|
|
|
|
//If we've already found a solution that is shorter than the path so far,
|
|
//there is no reason to continue
|
|
if(stepCount >= minPath) {
|
|
return false;
|
|
}
|
|
|
|
//If we've alreayd found a shorter path to this square then there is no
|
|
//sense in trying a longer path. This ended up shortening the time by
|
|
//alot.
|
|
if(stepCount >= shortestPaths[y][x]) {
|
|
return false;
|
|
} else {
|
|
shortestPaths[y][x] = stepCount;
|
|
}
|
|
|
|
//Print the rendering that is actually usesless once I found the solution
|
|
print();
|
|
if(input[y][x] === 69) {
|
|
minPath = Math.min(minPath, stepCount);
|
|
return true;
|
|
}
|
|
|
|
//Track what has been visited on the current path
|
|
visited[y][x] = true
|
|
|
|
const nextSteps = [[x + 1, y],[x, y + 1],[x, y - 1],[x - 1, y]];
|
|
|
|
//Try each direction
|
|
const found = nextSteps.map(nextStep => {
|
|
if(canVisit(loc, nextStep)) {
|
|
return explore(visited, nextStep, stepCount + 1);
|
|
}
|
|
return false
|
|
});
|
|
|
|
//Mark this one as no longer visited so we can try it again on another path.
|
|
visited[y][x] = false;
|
|
return false;
|
|
}
|
|
|
|
//start exploring
|
|
explore(visited, start, 0);
|
|
}
|
|
// Try starting from "S"
|
|
exploreMapFrom(start);
|
|
|
|
//Try starting from all the "a"s
|
|
for(let x = 0; x < maxX; ++x) {
|
|
for(let y = 0; y < maxY; ++y) {
|
|
if(input[y][x] === 97) {
|
|
exploreMapFrom([x, y]);
|
|
}
|
|
}
|
|
}
|
|
|
|
console.log(minPath);
|
|
}
|
|
|
|
main();
|