Count Reachable Values by Halving and Decrementing

Start from the nonnegative integer num. From any current value you may perform either allowed operation:
If the value is even, replace it with half of itself.
If the value is positive, replace it with one less.
For this exercise, assume you may perform at most steps operations. Count the distinct nonnegative values that can appear across all valid operation sequences, including the initial value reached with zero operations.

Function
countReachableValues(num: int, steps: int) → int

Examples
Example 1
num = 6
steps = 2
return = 5
The reachable values are 6, 5, 3, 4, and 2.
Example 2
num = 0
steps = 60
return = 1
Halving zero returns zero and decrement is unavailable, so only zero is reachable.
Example 3
num = 5
steps = 0
return = 1
With no operation allowed, only the initial value is counted.

Constraints
0 <= num <= 10^9.
0 <= steps <= 60.
The answer fits in a signed 32-bit integer.

The trick is noticing that steps is tiny. Each value has at most two moves, so the naive tree has up to 2^60 paths, but the set of distinct values is much smaller. Run BFS level by level with a visited set, and stop after steps levels. Halving and decrementing keep values within [0, num], and many paths collapse onto the same number, so dedup is what saves you. The pitfall is DFS without memoization, which blows up exponentially. Another one is forgetting the even check before halving, or letting zero decrement into -1. Zero halves to zero, so skip it as already visited. Also count the starting value at zero operations. Check example 1: 6 gives 5 and 3, then 4, 2 from those, so 5 values in total. The answer is the size of the visited set. If the set grows large, the guarantee that it fits in 32 bits keeps memory sane.

The honest play: practice the pattern, and have StealthCoder ready for the one you didn't see coming.