142 lines
2.6 KiB
Markdown
142 lines
2.6 KiB
Markdown
# Leetcode First-Bad-Version
|
||
|
||
#### 2022-07-09 09:52
|
||
|
||
> ##### Algorithms:
|
||
>
|
||
> #algorithm #binary_search
|
||
>
|
||
> ##### Data structures:
|
||
>
|
||
> #DS #array
|
||
>
|
||
> ##### Difficulty:
|
||
>
|
||
> #coding_problems #difficulty_easy
|
||
>
|
||
> ##### Additional tags:
|
||
>
|
||
> #leetcode
|
||
>
|
||
> ##### Revisions:
|
||
>
|
||
> N/A
|
||
|
||
##### Related topics:
|
||
|
||
##### Links:
|
||
|
||
- [Link to problem](https://leetcode.com/problems/first-bad-version/)
|
||
|
||
***
|
||
|
||
### Problem
|
||
|
||
You are a product manager and currently leading a team to develop a new product. Unfortunately, the latest version of your product fails the quality check. Since each version is developed based on the previous version, all the versions after a bad version are also bad.
|
||
|
||
Suppose you have `n` versions `[1, 2, ..., n]` and you want to find out the first bad one, which causes all the following ones to be bad.
|
||
|
||
You are given an API `bool isBadVersion(version)` which returns whether `version` is bad. Implement a function to find the first bad version. You should minimize the number of calls to the API.
|
||
|
||
#### Examples
|
||
|
||
**Example 1:**
|
||
|
||
**Input:** n = 5, bad = 4
|
||
**Output:** 4
|
||
**Explanation:**
|
||
call isBadVersion(3) -> false
|
||
call isBadVersion(5) -> true
|
||
call isBadVersion(4) -> true
|
||
Then 4 is the first bad version.
|
||
|
||
**Example 2:**
|
||
|
||
**Input:** n = 1, bad = 1
|
||
**Output:** 1
|
||
|
||
#### Constraints
|
||
|
||
- `1 <= bad <= n <= 231 - 1`
|
||
- ### Thoughts
|
||
|
||
> [!summary]
|
||
> This is a #binary_search problem
|
||
|
||
Note that constraints, n can be 2\*\*31, which means there might be integer overflow.
|
||
|
||
To address that, according to [[Binary Search Algorithm]], use `mid = l + (r - l) / 2`
|
||
|
||
In my first iteration,
|
||
I use a `first` variable to keep track of the first bad version.
|
||
|
||
Later I realized that by the definition of Bi-search, left boundary will converge to the first one.
|
||
|
||
### Solution
|
||
|
||
Second version, 0ms
|
||
|
||
```cpp
|
||
// The API isBadVersion is defined for you.
|
||
// bool isBadVersion(int version);
|
||
|
||
class Solution {
|
||
public:
|
||
int firstBadVersion(int n) {
|
||
// variant of BS
|
||
// 1-indexed
|
||
|
||
int r = n;
|
||
int l = 1;
|
||
int mid;
|
||
|
||
do {
|
||
mid = l + (r - l) / 2;
|
||
|
||
if (isBadVersion(mid)) {
|
||
// Search left
|
||
r = mid - 1;
|
||
} else {
|
||
l = mid + 1;
|
||
}
|
||
} while (l <= r);
|
||
|
||
return l;
|
||
}
|
||
};
|
||
```
|
||
|
||
First iteration, 4ms
|
||
|
||
```cpp
|
||
// The API isBadVersion is defined for you.
|
||
// bool isBadVersion(int version);
|
||
|
||
class Solution {
|
||
public:
|
||
int firstBadVersion(int n) {
|
||
// variant of BS
|
||
// 1-indexed
|
||
|
||
int r = n;
|
||
int l = 1;
|
||
int mid;
|
||
int first = n;
|
||
|
||
do {
|
||
mid = l + (r - l) / 2;
|
||
|
||
if (isBadVersion(mid)) {
|
||
first = min(n, mid);
|
||
// Search left
|
||
r = mid - 1;
|
||
} else {
|
||
l = mid + 1;
|
||
}
|
||
} while (l <= r);
|
||
|
||
return first;
|
||
}
|
||
};
|
||
```
|