AoC2025: day 9 part 2

Author: martapanc

2024-2025/src/2025/day09/day09.test.ts

@@ -8,8 +8,8 @@ describe('2025 Day 9', () => {
     });
 
     test('Part 2', async () => {
-        // expect(await part2('testInput1')).toEqual(31);
-        // expect(await part2('input')).toEqual(29379307);
+        expect(await part2('testInput1')).toEqual(24);
+        expect(await part2('input')).toEqual(1603439684);
     });
 
     test('findArea', async () => {
@@ -18,4 +18,4 @@ describe('2025 Day 9', () => {
         expect(findArea(new Coord(7, 3), new Coord(2, 3))).toEqual(6);
         expect(findArea(new Coord(7, 1), new Coord(11, 7))).toEqual(35);
     })
-});
+});

2024-2025/src/2025/day09/day09.ts

@@ -1,14 +1,13 @@
 import path from "node:path";
 import {readInputLineByLine} from "@utils/io";
 import {Coord} from "@utils/grid";
-import {Coord3d} from "@utils/grid3d";
 
 export async function part1(inputFile: string) {
     return await day9(inputFile, findAreaOfLargestRectangle);
 }
 
 export async function part2(inputFile: string) {
-    return await day9(inputFile);
+    return await day9(inputFile, findAreaOfLargestRectanglePart2);
 }
 
 async function day9(inputFile: string, calcFn?: (coords: Coord[]) => number) {
@@ -39,8 +38,177 @@ function findAreaOfLargestRectangle(coords: Coord[]): number {
     return maxArea;
 }
 
+function findAreaOfLargestRectanglePart2(coords: Coord[]): number {
+    const edges = buildEdges(coords);
+    const {xs, ys, xIndex, yIndex} = buildCompressedAxes(coords);
+    const prefix = buildInsidePrefix(edges, xs, ys);
+
+    let maxArea = 0;
+
+    for (let i = 0; i < coords.length; i++) {
+        const a = coords[i];
+        for (let j = i + 1; j < coords.length; j++) {
+            const b = coords[j];
+            if (a.equals(b)) continue;
+
+            const loX = Math.min(a.x, b.x);
+            const hiX = Math.max(a.x, b.x);
+            const loY = Math.min(a.y, b.y);
+            const hiY = Math.max(a.y, b.y);
+
+            const area = (hiX - loX + 1) * (hiY - loY + 1);
+            if (area <= maxArea) continue;
+
+            const x0 = xIndex.get(loX);
+            const x1 = xIndex.get(hiX + 1);
+            const y0 = yIndex.get(loY);
+            const y1 = yIndex.get(hiY + 1);
+            if (x0 === undefined || x1 === undefined || y0 === undefined || y1 === undefined) {
+                continue;
+            }
+
+            const insideSum =
+                prefix[y1][x1] -
+                prefix[y0][x1] -
+                prefix[y1][x0] +
+                prefix[y0][x0];
+
+            if (insideSum === area) {
+                maxArea = area;
+            }
+        }
+    }
+
+    return maxArea;
+}
+
 export function findArea(a: Coord, b: Coord): number {
     const sideA = Math.abs(a.x - b.x) + 1;
     const sideB = Math.abs(a.y - b.y) + 1;
     return sideA * sideB;
-}
+}
+
+type VerticalEdge = { x: number; loY: number; hiY: number };
+type HorizontalEdge = { y: number; loX: number; hiX: number };
+type Edges = { vertical: VerticalEdge[]; horizontal: HorizontalEdge[] };
+
+function buildEdges(coords: Coord[]): Edges {
+    const vertical: VerticalEdge[] = [];
+    const horizontal: HorizontalEdge[] = [];
+
+    for (let i = 0; i < coords.length; i++) {
+        const a = coords[i];
+        const b = coords[(i + 1) % coords.length];
+
+        if (a.x === b.x) {
+            const loY = Math.min(a.y, b.y);
+            const hiY = Math.max(a.y, b.y);
+            vertical.push({x: a.x, loY, hiY});
+        } else {
+            const loX = Math.min(a.x, b.x);
+            const hiX = Math.max(a.x, b.x);
+            horizontal.push({y: a.y, loX, hiX});
+        }
+    }
+
+    return {vertical, horizontal};
+}
+
+function buildCompressedAxes(coords: Coord[]) {
+    const xsSet = new Set<number>();
+    const ysSet = new Set<number>();
+
+    for (const c of coords) {
+        xsSet.add(c.x);
+        xsSet.add(c.x + 1);
+        ysSet.add(c.y);
+        ysSet.add(c.y + 1);
+    }
+
+    const xs = Array.from(xsSet).sort((a, b) => a - b);
+    const ys = Array.from(ysSet).sort((a, b) => a - b);
+
+    const xIndex = new Map<number, number>();
+    const yIndex = new Map<number, number>();
+
+    xs.forEach((x, i) => xIndex.set(x, i));
+    ys.forEach((y, i) => yIndex.set(y, i));
+
+    return {xs, ys, xIndex, yIndex};
+}
+
+function buildInsidePrefix(edges: Edges, xs: number[], ys: number[]) {
+    const rowCount = ys.length - 1;
+    const colCount = xs.length - 1;
+    const dx = new Array<number>(colCount);
+    for (let i = 0; i < colCount; i++) {
+        dx[i] = xs[i + 1] - xs[i];
+    }
+    const xIndex = new Map<number, number>();
+    xs.forEach((x, i) => xIndex.set(x, i));
+
+    const prefix: Float64Array[] = [];
+    prefix.push(new Float64Array(colCount + 1));
+
+    for (let row = 0; row < rowCount; row++) {
+        const y = ys[row];
+        const height = ys[row + 1] - y;
+
+        const crossings: number[] = [];
+        for (const edge of edges.vertical) {
+            if (y >= edge.loY && y < edge.hiY) {
+                crossings.push(edge.x);
+            }
+        }
+        crossings.sort((a, b) => a - b);
+
+        const intervals: Array<[number, number]> = [];
+        for (let i = 0; i + 1 < crossings.length; i += 2) {
+            const start = crossings[i];
+            const endInclusive = crossings[i + 1];
+            intervals.push([start, endInclusive + 1]);
+        }
+
+        for (const edge of edges.horizontal) {
+            if (edge.y === y) {
+                intervals.push([edge.loX, edge.hiX + 1]);
+            }
+        }
+
+        intervals.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+
+        const merged: Array<[number, number]> = [];
+        for (const [start, end] of intervals) {
+            if (merged.length === 0) {
+                merged.push([start, end]);
+                continue;
+            }
+            const last = merged[merged.length - 1];
+            if (start <= last[1]) {
+                if (end > last[1]) last[1] = end;
+            } else {
+                merged.push([start, end]);
+            }
+        }
+
+        const rowWeights = new Float64Array(colCount);
+        for (const [start, end] of merged) {
+            const startIndex = xIndex.get(start);
+            const endIndex = xIndex.get(end);
+            if (startIndex === -1 || endIndex === -1) continue;
+            if (startIndex === undefined || endIndex === undefined) continue;
+            for (let x = startIndex; x < endIndex; x++) {
+                rowWeights[x] = dx[x] * height;
+            }
+        }
+
+        const prev = prefix[row];
+        const current = new Float64Array(colCount + 1);
+        for (let x = 0; x < colCount; x++) {
+            current[x + 1] = prev[x + 1] + current[x] - prev[x] + rowWeights[x];
+        }
+        prefix.push(current);
+    }
+
+    return prefix;
+}