vault backup: 2022-07-09 10:02:11

OJ notes/pages/Binary Search Algorithm.md

@@ -29,6 +29,16 @@ Use cpp's set's [find](https://en.cppreference.com/w/cpp/container/set/find)
 or [equal_range](https://en.cppreference.com/w/cpp/container/multiset/equal_range)
 
 #### b: Manual
+
+##### Tips:
+
+> [!tip] Why `mid = l + (r - l) / 2`, not `mid = (l + r) / 2`
+> Avoids integer overflow when l and r is big
+
+> [!tip] Why `r = array.size() - 1`
+> Avoids OOB when (l == r && r == array.size())
+> This happens if 1 is not subtracted
+
 1. Use a while loop:
 [[Leetcode Search-a-2D-Matrix#Solution]]
 

OJ notes/pages/Leetcode Binary-Search.md

@@ -18,6 +18,10 @@
 tag:#binary_search
 ```
  
+- [[Binary Search Algorithm]]
+- [[Leetcode Lowest-Common-Ancestor-Of-a-Binary-Search-Tree]]
+- [[Leetcode Search-a-2D-Matrix]]
+- [[Leetcode Two-Sum-IV-Input-Is-a-BST]]
  
 
 ##### Links:

OJ notes/pages/Leetcode First-Bad-Version.md

@@ -0,0 +1,98 @@
+# Leetcode First-Bad-Version
+
+#### 2022-07-09 09:52
+
+> ##### Algorithms:
+> #algorithm #binary_search 
+> ##### Data structures:
+> #DS #array 
+> ##### Difficulty:
+> #coding_problem #difficulty-easy 
+> ##### Additional tags:
+> #leetcode
+> ##### Revisions:
+> N/A
+
+##### Related topics:
+```expander
+tag:#binary_search
+```
+ 
+ 
+
+##### 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 [[Leetcode First-Bad-Version#Constraints]], n can be 2**31, which means there might be integer overflow.
+
+To address that, according to [[Binary Search Algorithm#How to implement Binary search]], use `mid = l + (r - l) / 2`
+
+I use a `first` variable to keep track of the first bad version.
+
+### Solution
+
+```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;
+  }
+};
+```