Given two integers `A` and `B`, transform `A` into `B` using the minimum number of operations. At each step you may apply exactly one of the following operations to the current value: 1. **Subtract 1** from the current value. 2. **Multiply** the current value **by 2**. Return the minimum number of operations needed to turn `A` into `B`. **Approach (reverse-greedy).** Searching forward from `A` is expensive because multiplying by 2 explodes the state space. Instead, work backward from `B` toward `A`, inverting each operation: - The inverse of "multiply by 2" is "divide by 2" (only valid when the value is even). - The inverse of "subtract 1" is "add 1". While `B > A`: if `B` is even, halve it (undo a multiply); if `B` is odd, add 1 (undo a subtract so it becomes even and can later be halved). Each such step counts as one operation. Once `B <= A`, the only remaining way to reach `A` is to subtract 1 repeatedly, which adds exactly `A - B` more operations. This greedy is provably optimal: a smaller odd target can only be reached from a larger value via a `-1` step, so making `B` even by `+1` (reverse) before halving is always at least as good as any alternative. **Examples:** - `A = 1, B = 2`: `1 x 2 = 2` -> **1** operation. - `A = 9, B = 1`: subtract 1 eight times -> **8** operations. - `A = 2, B = 10`: `2 x 2 = 4`, `4 - 1 = 3`, `3 x 2 = 6`, `6 - 1 = 5`, `5 x 2 = 10` -> **5** operations. - `A = 100, B = 500`: **41** operations.