Faster implementation using reversed vec as a heap

Author: maneatingape

README.md

@@ -80,7 +80,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 6 | [Guard Gallivant](https://adventofcode.com/2024/day/6) | [Source](src/year2024/day06.rs) | 386 |
 | 7 | [Bridge Repair](https://adventofcode.com/2024/day/7) | [Source](src/year2024/day07.rs) | 136 |
 | 8 | [Resonant Collinearity](https://adventofcode.com/2024/day/8) | [Source](src/year2024/day08.rs) | 8 |
-| 9 | [Disk Fragmenter](https://adventofcode.com/2024/day/9) | [Source](src/year2024/day09.rs) | 163 |
+| 9 | [Disk Fragmenter](https://adventofcode.com/2024/day/9) | [Source](src/year2024/day09.rs) | 109 |
 | 10 | [Hoof It](https://adventofcode.com/2024/day/10) | [Source](src/year2024/day10.rs) | 38 |
 
 ## 2023

src/year2024/day09.rs

@@ -9,12 +9,12 @@
 //!
 //! We build 10 [min heaps](https://en.wikipedia.org/wiki/Heap_(data_structure)) in an array to
 //! store the free space offsets. The index of the array implicitly stores the size of the
-//! free block.
+//! free block. The heaps are implemented as a simple revered `vec`. Most frequently
+//! items are added directly to the top of the heap, so this is faster than a real heap.
 //!
 //! When moving a file to a free block, the corresponding heap is popped and then any leftover
 //! space is pushed back to the heap at a smaller index. The heap at index zero is not used
 //! but makes the indexing easier.
-use crate::util::heap::*;
 
 /// [Triangular numbers](https://en.wikipedia.org/wiki/Triangular_number) offset by two.
 /// Files can be a max size of 9 so we only need the first 10 values, including zero to make
@@ -63,21 +63,28 @@ pub fn part1(disk: &[usize]) -> usize {
     checksum
 }
 
+#[allow(clippy::needless_range_loop)]
 pub fn part2(disk: &[usize]) -> usize {
     let mut block = 0;
     let mut checksum = 0;
-    let mut free: Vec<_> = (0..10).map(|_| MinHeap::with_capacity(1_000)).collect();
+    let mut free: Vec<_> = (0..10).map(|_| Vec::with_capacity(1_000)).collect();
 
     // Build a min-heap (leftmost free block first) where the size of each block is
     // implicit in the index of the array.
     for (index, &size) in disk.iter().enumerate() {
         if index % 2 == 1 && size > 0 {
-            free[size].push(block, ());
+            free[size].push(block);
         }
 
         block += size;
     }
 
+    // Add sentinel value and reverse vecs so that smallest blocks are last.
+    for i in 0..10 {
+        free[i].push(block);
+        free[i].reverse();
+    }
+
     for (index, &size) in disk.iter().enumerate().rev() {
         block -= size;
 
@@ -90,25 +97,25 @@ pub fn part2(disk: &[usize]) -> usize {
         let mut next_block = block;
         let mut next_index = usize::MAX;
 
-        #[allow(clippy::needless_range_loop)]
         for i in size..free.len() {
-            if let Some((&first, ())) = free[i].peek() {
-                if first < next_block {
-                    next_block = first;
-                    next_index = i;
-                }
+            let top = free[i].len() - 1;
+            let first = free[i][top];
+
+            if first < next_block {
+                next_block = first;
+                next_index = i;
             }
         }
 
         // We can make smaller free block from bigger blocks but not the other way around.
         // As an optimization if all blocks of the biggest size are after our position then
         // we can ignore them.
         if !free.is_empty() {
-            let last = free.len() - 1;
-            if let Some((&first, ())) = free[last].peek() {
-                if first > block {
-                    free.pop();
-                }
+            let biggest = free.len() - 1;
+            let top = free[biggest].len() - 1;
+
+            if free[biggest][top] > block {
+                free.pop();
             }
         }
 
@@ -120,8 +127,20 @@ pub fn part2(disk: &[usize]) -> usize {
         // If we used a free block, remove then add back any leftover space.
         if next_index != usize::MAX {
             free[next_index].pop();
-            if size < next_index {
-                free[next_index - size].push(next_block + size, ());
+
+            // Insert the new smaller block into the correct location.
+            // Most frequently this is directly at the end of the vector so even though this
+            // is technically `O(n)`, in practice it's faster than a real heap.
+            let to = next_index - size;
+            if to > 0 {
+                let mut i = free[to].len();
+                let value = next_block + size;
+
+                while free[to][i - 1] < value {
+                    i -= 1;
+                }
+
+                free[to].insert(i, value);
             }
         }
     }