hackercupai/hackercup huggingface dataset:
If there are no ladders touching the ground, the answer is \(0\). Otherwise, those can all be inspected for free, and only the one with the largest \(B\) value is relevant.

We can perform a line sweep upwards over the ladders' endpoints (including the top of the tallest grounded ladder) while greedily constructing \(2\) "paths" of ladders simultaneously (one for the way up from the ground, and another for the way back down).

We'll maintain the ongoing ladders \(a\) and \(b\) for the \(2\) paths (not necessarily distinct, and both initially equal to the grounded ladder), the set \(U\) of ongoing ladders not yet used in either path (ordered by their \(B\) values, and initially empty), and the number of ladders inspected \(I\) and number of jumps used \(J\). We'll maintain an invariant that \(B_b\) is always greater than or equal to the \(B\) values of all other ongoing ladders not in \(U\) (including \(a\)). For convenience, we'll also assume that \(b\)'s top comes after \(a\)'s top in the line sweep (in case \(a \ne b\) and \(B_a = B_b\)).

When we encounter the bottom of a ladder, we'll simply add it to \(U\).

When we encounter the top of ladder \(i\), if \(i\) is in \(U\), then this is our last chance to visit it. So, we'll jump from ladder a to ladder \(i\) (leaving ladder \(b\) alone), removing \(i\) from \(U\), setting a to equal \(i\), and incrementing \(I\) and \(J\).

Either way, ladder \(i\)'s top being reached is then only relevant if \(i = a\) (and potentially also \(i = b\)), as we must jump to different ladder(s) to continue the path(s). One of the following situations will apply:

1. If \(U\) is empty and \(i = a = b\), we should terminate the line sweep, as both paths have converged and there are no higher ladders to jump to.

2. If \(U\) is empty but \(a \ne b\) (with \(i = a\)), we'll jump from ladder \(a\) to ladder \(b\) (necessary to attempt to continue \(a\)'s path or at least converge with \(b\)'s path), setting \(a\) to equal \(b\) and incrementing \(J\).

3. Otherwise, if \(U\) is non-empty, we'll jump from ladder \(a\) to the ladder \(j\) in \(U\) with the smallest \(B\) value, removing \(j\) from \(U\), setting \(a\) to equal \(j\), and incrementing \(I\) and \(J\). If \(i = b\), then we'll repeat this process to similarly jump from ladder \(b\) to the ladder in \(U\) with the next-smallest \(B\) value (though if \(U\) has become empty, then we'll instead need to jump from ladder \(b\) to the new ladder \(a\)). We may need to then swap \(a\) and \(b\) to maintain the aforementioned invariant regarding ladder \(b\).

The time complexity of this algorithm is \(O(N \log(N))\).