aoc23-16.mts

import { Advent, f, fm, chr, ord } from "advent";
import { Set, Map } from "immutable";

const { compute, computeCheck } = await Advent({ day: 16 });

compute(2, async (input) => {
	const data = input.parse(f.cGrid());
	let ans = 0;
	for (let i = 0; i < data.length; i++) {
		console.log(i);
		ans = Math.max(ans, count(data, i, 0, 0));
		ans = Math.max(ans, count(data, i, data[i].length - 1, 2));
	}
	for (let j = 0; j < data[0].length; j++) {
		console.log(j);
		ans = Math.max(ans, count(data, 0, j, 1));
		ans = Math.max(ans, count(data, data.length - 1, j, 3));
	}
	return ans;
});

function count(data: string[][], startI: number, startJ: number, startD: number): number {
	let visited = Set<string>();
	let energized = Set<string>();
	let queue: [number, number, number][] = [[startI, startJ, startD]]; // directions: right, down, left, up

	while (queue.length > 0) {
		let [i, j, d] = queue.shift()!;
		// console.log(i, j, d);
		if (i < 0 || i >= data.length || j < 0 || j >= data[i].length) {
			continue;
		}
		const loc = `${i},${j}`;
		energized = energized.add(loc);

		switch (data[i][j]) {
			case ".": {
				const [i2, j2] = step(i, j, d);
				if (!visited.has(key(i2, j2, d))) {
					queue.push([i2, j2, d]);
					visited = visited.add(key(i2, j2, d));
				}
				break;
			}

			case "/": {
				const newD = (
					d == 0 ? 3 :
					d == 1 ? 2 :
					d == 2 ? 1 :
					0
				);
				const [i2, j2] = step(i, j, newD);
				if (!visited.has(key(i2, j2, newD))) {
					queue.push([i2, j2, newD]);
					visited = visited.add(key(i2, j2, newD));
				}
				break;
			}

			case "\\": {
				const newD = (
					d == 0 ? 1 :
					d == 1 ? 0 :
					d == 2 ? 3 :
					2
				);
				const [i2, j2] = step(i, j, newD);
				if (!visited.has(key(i2, j2, newD))) {
					queue.push([i2, j2, newD]);
					visited = visited.add(key(i2, j2, newD));
				}
				break;
			}

			case "-": {
				if (d == 0 || d == 2) {
					const [i2, j2] = step(i, j, d);
					if (!visited.has(key(i2, j2, d))) {
						queue.push([i2, j2, d]);
						visited = visited.add(key(i2, j2, d));
					}
				} else {
					for (const newD of [0, 2]) {
						const [i2, j2] = step(i, j, newD);
						if (!visited.has(key(i2, j2, newD))) {
							queue.push([i2, j2, newD]);
							visited = visited.add(key(i2, j2, newD));
						}
					}
				}
				break;
			}

			case "|": {
				if (d == 1 || d == 3) {
					const [i2, j2] = step(i, j, d);
					if (!visited.has(key(i2, j2, d))) {
						queue.push([i2, j2, d]);
						visited = visited.add(key(i2, j2, d));
					}
				} else {
					for (const newD of [1, 3]) {
						const [i2, j2] = step(i, j, newD);
						if (!visited.has(key(i2, j2, newD))) {
							queue.push([i2, j2, newD]);
							visited = visited.add(key(i2, j2, newD));
						}
					}
				}
				break;
			}
		}
	}


	return energized.size;
}

function key(i: number, j: number, d: number) {
	return `${i},${j},${d}`;
}

function step(i: number, j: number, d: number): [number, number] {
	switch (d) {
		case 0: return [i, j + 1];
		case 1: return [i + 1, j];
		case 2: return [i, j - 1];
		case 3: return [i - 1, j];
		default: throw new Error();
	}
}