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>'R'</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:
Solutions#
Solution 1#
1
2
3
4
5
6
7
8
9
10
11
12
| 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]
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| 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];
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| 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];
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| 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]
}
|
