add 14

Author: geemaple

README.md

@@ -44,12 +44,12 @@ python problem.py https://www.lintcode.com/problem/92 -l cpp
 | [✅] | [blind75.md](./list/blind75.md) | 77/77 | - |
 | [✅] | [geekbang.md](./list/geekbang.md) | 55/55 | - |
 | [✅] | [leetcode101.md](./list/leetcode101.md) | 183/184 | 1 vip |
-| [🔲] | [9c-basic.md](./list/9c-basic.md) | 1/128 | - |
+| [🔲] | [9c-basic.md](./list/9c-basic.md) | 2/128 | 1 vip |
 | [🔲] | [9c-top.md](./list/9c-top.md) | 5/48 | - |
 | [🔲] | [leetcode-contest.md](./list/leetcode-contest.md) | 10/56 | - |
 | [🔲] | [leetcode-google.md](./list/leetcode-google.md) | 0/7 | - |
 
-**Solved**: 456 problems
+**Solved**: 457 problems
 
 ## 类型/Category
 
@@ -305,7 +305,7 @@ python problem.py https://www.lintcode.com/problem/92 -l cpp
 
 ## Binary Search
 
-| Link | Problem(39) | Solution | Tag | Time | Space | Ref |
+| Link | Problem(40) | Solution | Tag | Time | Space | Ref |
 | ----- | ----- | ----- | ----- | ----- | ----- | ----- |
 | [Leetcode-704](https://leetcode.com/problems/binary-search/) | Binary Search | [c++](./leetcode/704.binary-search.cpp), [python3](./leetcode/704.binary-search.py) | Binary Search | O\(logN\) | O\(1\) | - |
 | [Leetcode-3048](https://leetcode.com/problems/earliest-second-to-mark-indices-i/) | Earliest Second To Mark Indices I | [c++](./leetcode/3048.earliest-second-to-mark-indices-i.cpp), [python3](./leetcode/3048.earliest-second-to-mark-indices-i.py) | Binary Search | O\(NlogN\) | O\(N\) | - |
@@ -343,6 +343,7 @@ python problem.py https://www.lintcode.com/problem/92 -l cpp
 | [Leetcode-367](https://leetcode.com/problems/valid-perfect-square/) | Valid Perfect Square | [c++](./leetcode/367.valid-perfect-square.cpp), [python3](./leetcode/367.valid-perfect-square.py) | Binary Search | O\(logN\) | O\(1\) | - |
 | [Lintcode-457](https://www.lintcode.com/problem/classical-binary-search/) | Classical Binary Search | [c++](./lintcode/457.classical-binary-search.cpp), [python3](./lintcode/457.classical-binary-search.py) | Binary Search | O\(logN\) | O\(1\) | - |
 | [Lintcode-437](https://www.lintcode.com/problem/copy-books/) | Copy Books | [c++](./lintcode/437.copy-books.cpp), [python3](./lintcode/437.copy-books.py) | Binary Search | O\(N\*logP\) | O\(1\) | - |
+| [Lintcode-14](https://www.lintcode.com/problem/first-position-of-target/) | First Position Of Target | [c++](./lintcode/14.first-position-of-target.cpp), [python3](./lintcode/14.first-position-of-target.py) | Binary Search | O\(logN\) | O\(1\) | - |
 | [Lintcode-617](https://www.lintcode.com/problem/maximum-average-subarray-ii/) | Maximum Average Subarray II | [c++](./lintcode/617.maximum-average-subarray-ii.cpp), [python3](./lintcode/617.maximum-average-subarray-ii.py) | Binary Search | O\(Nlog\(A/ε\)\) | O\(N\) | Leetcode-644 |
 | [Lintcode-600](https://www.lintcode.com/problem/smallest-rectangle-enclosing-black-pixels/) | Smallest Rectangle Enclosing Black Pixels | [c++](./lintcode/600.smallest-rectangle-enclosing-black-pixels.cpp), [python3](./lintcode/600.smallest-rectangle-enclosing-black-pixels.py) | Binary Search | O\(N \* logM \+ M \* logN\) | O\(1\) | - |
 | [Lintcode-183](https://www.lintcode.com/problem/wood-cut/) | Wood Cut | [c++](./lintcode/183.wood-cut.cpp), [python3](./lintcode/183.wood-cut.py) | Binary Search | O\(NlogA\) | O\(1\) | - |

lintcode/14.first-position-of-target.cpp

@@ -0,0 +1,87 @@
+//  Tag: Binary Search
+//  Time: O(logN)
+//  Space: O(1)
+//  Ref: -
+//  Note: -
+
+//  Given a sorted array (ascending order) and a `target` number, find the first index of this number in $O(log n)$ time complexity.
+//  
+//  If the `target` number does not exist in the array, return `-1`.
+//  
+//  **Example 1:**  
+//   
+//  Input:  
+//  ``` 
+//  tuple = [1,4,4,5,7,7,8,9,9,10]
+//  target = 1
+//  ``` 
+//  Output:  
+//  ``` 
+//  0
+//  ``` 
+//  Explanation:  
+//  
+//  The first index of  1 is 0.
+//  
+//  **Example 2:**  
+//   
+//  Input:  
+//  ``` 
+//  tuple = [1, 2, 3, 3, 4, 5, 10]
+//  target = 3
+//  ``` 
+//  Output:  
+//  ``` 
+//  2
+//  ``` 
+//  Explanation:  
+//  
+//  The first index of 3 is 2.
+//  
+//  **Example 3:**  
+//   
+//  Input:  
+//  ``` 
+//  tuple = [1, 2, 3, 3, 4, 5, 10]
+//  target = 6
+//  ``` 
+//  Output:  
+//  ``` 
+//  -1
+//  ``` 
+//  Explanation:  
+//  
+//  There is no 6 in the array，return -1.
+//  
+//  
+
+class Solution {
+public:
+    /**
+     * @param nums: The integer array.
+     * @param target: Target to find.
+     * @return: The first position of target. Position starts from 0.
+     */
+    int binarySearch(vector<int> &nums, int target) {
+        // write your code here
+        int n = nums.size();
+        if (n == 0) {
+            return -1;
+        }
+
+
+        int left = 0;
+        int right = n - 1;
+        while (left < right) {
+            int mid = left + (right - left) / 2;
+            if (nums[mid] < target) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+
+        return nums[left] == target ? left : -1;
+
+    }
+};

lintcode/14.first-position-of-target.py

@@ -0,0 +1,84 @@
+#  Tag: Binary Search
+#  Time: O(logN)
+#  Space: O(1)
+#  Ref: -
+#  Note: -
+
+#  Given a sorted array (ascending order) and a `target` number, find the first index of this number in $O(log n)$ time complexity.
+#  
+#  If the `target` number does not exist in the array, return `-1`.
+#  
+#  **Example 1:**  
+#   
+#  Input:  
+#  ``` 
+#  tuple = [1,4,4,5,7,7,8,9,9,10]
+#  target = 1
+#  ``` 
+#  Output:  
+#  ``` 
+#  0
+#  ``` 
+#  Explanation:  
+#  
+#  The first index of  1 is 0.
+#  
+#  **Example 2:**  
+#   
+#  Input:  
+#  ``` 
+#  tuple = [1, 2, 3, 3, 4, 5, 10]
+#  target = 3
+#  ``` 
+#  Output:  
+#  ``` 
+#  2
+#  ``` 
+#  Explanation:  
+#  
+#  The first index of 3 is 2.
+#  
+#  **Example 3:**  
+#   
+#  Input:  
+#  ``` 
+#  tuple = [1, 2, 3, 3, 4, 5, 10]
+#  target = 6
+#  ``` 
+#  Output:  
+#  ``` 
+#  -1
+#  ``` 
+#  Explanation:  
+#  
+#  There is no 6 in the array，return -1.
+#  
+#  
+
+from typing import (
+    List,
+)
+
+class Solution:
+    """
+    @param nums: The integer array.
+    @param target: Target to find.
+    @return: The first position of target. Position starts from 0.
+    """
+    def binary_search(self, nums: List[int], target: int) -> int:
+        # write your code here
+        n = len(nums)
+        if n == 0:
+            return -1
+
+        left = 0
+        right = n - 1
+
+        while left < right:
+            mid = left + (right - left) // 2
+            if nums[mid] < target:
+                left = mid + 1
+            else:
+                right = mid
+
+        return left if nums[left] == target else -1

lintcode/458.last-position-of-target.vip

@@ -8,8 +8,8 @@
 ### 二分法
 
 3. https://www.lintcode.com/problem/classical-binary-search/
-- https://www.lintcode.com/problem/first-position-of-target/
-- https://www.lintcode.com/problem/last-position-of-target/
+4. https://www.lintcode.com/problem/first-position-of-target/
+5. https://www.lintcode.com/problem/last-position-of-target/
 - https://www.lintcode.com/problem/first-bad-version/
 - https://www.lintcode.com/problem/search-in-a-big-sorted-array/
 - https://www.lintcode.com/problem/find-minimum-in-rotated-sorted-array/

list/9c-basic.md

@@ -8,37 +8,40 @@
 
 import heapq
 
+from typing import (
+    List,
+)
+
 class Solution:
-    def minTimeToReach(self, moveTime: List[List[int]]) -> int:
-        n = len(moveTime)
-        m = len(moveTime[0])
-
-        heap = [(0, 0, 0, 0)]
-        directions = [-1, 0, 1, 0, -1]
-        visited = set()
-
-        res = float('inf')
-        while len(heap) > 0:
-            cost, i, j, delta = heapq.heappop(heap)
-            if (i, j) in visited:
-                continue
-
-            visited.add((i, j))
-            if i == n - 1 and j == m - 1:
-                return cost
-
-            for d in range(4):
-                x = i + directions[d]
-                y = j + directions[d + 1]
-                if 0 <= x < n and 0 <= y < m and (x, y) not in visited:
-                    next_cost = max(moveTime[x][y], cost) + delta + 1
-                    heapq.heappush(heap, (next_cost, x, y, 1 - delta))
+    """
+    @param nums: The integer array.
+    @param target: Target to find.
+    @return: The first position of target. Position starts from 0.
+    """
+    def binary_search(self, nums: List[int], target: int) -> int:
+        # write your code here
+        n = len(nums)
+        if n == 0:
+            return -1
+
+        print(n)
+        left = 0
+        right = n - 1
+
+        while left < right:
+            mid = left + (right - left) // 2
+            if nums[mid] < target:
+                left = mid + 1
+            else:
+                right = mid
+
+        return left if nums[left] == target else -1
 
 
 s = Solution()
 ts = datetime.now()
 
-res = s.minTimeToReach([[0,1],[1,2]])
+res = s.binary_search([], 6)
 
 print(datetime.now() - ts)
 print(res)