LeetCode 0818. Race Car Solution in Java, C++, Python & Go | Explanation + Code

Description

Your car starts at position 0 and speed +1 on an infinite number line. Your car can go into negative positions. Your car drives automatically according to a sequence of instructions 'A' (accelerate) and 'R' (reverse):

• When you get an instruction 'A', your car does the following:

  <ul>
  	<li><code>position += speed</code></li>
  	<li><code>speed *= 2</code></li>
  </ul>
  </li>
  <li>When you get an instruction <code>&#39;R&#39;</code>, your car does the following:
  <ul>
  	<li>If your speed is positive then <code>speed = -1</code></li>
  	<li>otherwise <code>speed = 1</code></li>
  </ul>
  Your position stays the same.</li>
  

For example, after commands "AAR", your car goes to positions 0 --> 1 --> 3 --> 3, and your speed goes to 1 --> 2 --> 4 --> -1.

Given a target position target, return the length of the shortest sequence of instructions to get there.

 

Example 1:

Input: target = 3
Output: 2
Explanation: 
The shortest instruction sequence is "AA".
Your position goes from 0 --> 1 --> 3.

Example 2:

Input: target = 6
Output: 5
Explanation: 
The shortest instruction sequence is "AAARA".
Your position goes from 0 --> 1 --> 3 --> 7 --> 7 --> 6.

 

Constraints:

• 1 <= target <= 104

Solutions

Solution 1

PythonJavaC++Go

class Solution: def racecar(self, target: int) -> int: dp = [0] * (target + 1) for i in range(1, target + 1): k = i.bit_length() if i == 2**k - 1: dp[i] = k continue dp[i] = dp[2**k - 1 - i] + k + 1 for j in range(k - 1): dp[i] = min(dp[i], dp[i - (2 ** (k - 1) - 2**j)] + k - 1 + j + 2) return dp[target](code-box)

class Solution { public int racecar(int target) { int[] dp = new int[target + 1]; for (int i = 1; i <= target; ++i) { int k = 32 - Integer.numberOfLeadingZeros(i); if (i == (1 << k) - 1) { dp[i] = k; continue; } dp[i] = dp[(1 << k) - 1 - i] + k + 1; for (int j = 0; j < k; ++j) { dp[i] = Math.min(dp[i], dp[i - (1 << (k - 1)) + (1 << j)] + k - 1 + j + 2); } } return dp[target]; } }(code-box)

class Solution { public: int racecar(int target) { vector<int> dp(target + 1); for (int i = 1; i <= target; ++i) { int k = 32 - __builtin_clz(i); if (i == (1 << k) - 1) { dp[i] = k; continue; } dp[i] = dp[(1 << k) - 1 - i] + k + 1; for (int j = 0; j < k; ++j) { dp[i] = min(dp[i], dp[i - (1 << (k - 1)) + (1 << j)] + k - 1 + j + 2); } } return dp[target]; } };(code-box)

func racecar(target int) int { dp := make([]int, target+1) for i := 1; i <= target; i++ { k := bits.Len(uint(i)) if i == (1<<k)-1 { dp[i] = k continue } dp[i] = dp[(1<<k)-1-i] + k + 1 for j := 0; j < k; j++ { dp[i] = min(dp[i], dp[i-(1<<(k-1))+(1<<j)]+k-1+j+2) } } return dp[target] }(code-box)