feat: add solutions to lc problems: No.1095, 1122

* No.1095: Find in Mountain Array
* No.1122: Relative Sort Array

Author: yanglbme

solution/1000-1099/1095.Find in Mountain Array/README.md

@@ -74,22 +74,229 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：二分查找**
+
+我们先通过二分查找，找到数组中的最大值所在的下标 $l$，那么数组就可以被分成两段，前半段是递增的，后半段是递减的。
+
+然后我们在前半段中使用二分查找，查找目标值所在的下标，如果找不到，再在后半段中使用二分查找，查找目标值所在的下标。
+
+时间复杂度 $O(\log n)$，其中 $n$ 是数组的长度。空间复杂度 $O(1)$。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+# """
+# This is MountainArray's API interface.
+# You should not implement it, or speculate about its implementation
+# """
+# class MountainArray:
+#    def get(self, index: int) -> int:
+#    def length(self) -> int:
+
+class Solution:
+    def findInMountainArray(self, target: int, mountain_arr: 'MountainArray') -> int:
+        def search(l: int, r: int, k: int) -> int:
+            while l < r:
+                mid = (l + r) >> 1
+                if k * mountain_arr.get(mid) >= k * target:
+                    r = mid
+                else:
+                    l = mid + 1
+            return -1 if mountain_arr.get(l) != target else l
+
+        n = mountain_arr.length()
+        l, r = 0, n - 1
+        while l < r:
+            mid = (l + r) >> 1
+            if mountain_arr.get(mid) > mountain_arr.get(mid + 1):
+                r = mid
+            else:
+                l = mid + 1
+        ans = search(0, l, 1)
+        return search(l + 1, n - 1, -1) if ans == -1 else ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+/**
+ * // This is MountainArray's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * interface MountainArray {
+ *     public int get(int index) {}
+ *     public int length() {}
+ * }
+ */
+
+class Solution {
+    private MountainArray mountainArr;
+    private int target;
+
+    public int findInMountainArray(int target, MountainArray mountainArr) {
+        int n = mountainArr.length();
+        int l = 0, r = n - 1;
+        while (l < r) {
+            int mid = (l + r) >>> 1;
+            if (mountainArr.get(mid) > mountainArr.get(mid + 1)) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        }
+        this.mountainArr = mountainArr;
+        this.target = target;
+        int ans = search(0, l, 1);
+        return ans == -1 ? search(l + 1, n - 1, -1) : ans;
+    }
+
+    private int search(int l, int r, int k) {
+        while (l < r) {
+            int mid = (l + r) >>> 1;
+            if (k * mountainArr.get(mid) >= k * target) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        }
+        return mountainArr.get(l) == target ? l : -1;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+/**
+ * // This is the MountainArray's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * class MountainArray {
+ *   public:
+ *     int get(int index);
+ *     int length();
+ * };
+ */
+
+class Solution {
+public:
+    int findInMountainArray(int target, MountainArray &mountainArr) {
+        int n = mountainArr.length();
+        int l = 0, r = n - 1;
+        while (l < r) {
+            int mid = (l + r) >> 1;
+            if (mountainArr.get(mid) > mountainArr.get(mid + 1)) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        }
+        auto search = [&](int l, int r, int k) -> int {
+            while (l < r) {
+                int mid = (l + r) >> 1;
+                if (k * mountainArr.get(mid) >= k * target) {
+                    r = mid;
+                } else {
+                    l = mid + 1;
+                }
+            }
+            return mountainArr.get(l) == target ? l : -1;
+        };
+        int ans = search(0, l, 1);
+        return ans == -1 ? search(l + 1, n - 1, -1) : ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+/**
+ * // This is the MountainArray's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * type MountainArray struct {
+ * }
+ *
+ * func (this *MountainArray) get(index int) int {}
+ * func (this *MountainArray) length() int {}
+ */
+
+func findInMountainArray(target int, mountainArr *MountainArray) int {
+	n := mountainArr.length()
+	l, r := 0, n-1
+	for l < r {
+		mid := (l + r) >> 1
+		if mountainArr.get(mid) > mountainArr.get(mid+1) {
+			r = mid
+		} else {
+			l = mid + 1
+		}
+	}
+	search := func(l, r, k int) int {
+		for l < r {
+			mid := (l + r) >> 1
+			if k*mountainArr.get(mid) >= k*target {
+				r = mid
+			} else {
+				l = mid + 1
+			}
+		}
+		if mountainArr.get(l) == target {
+			return l
+		}
+		return -1
+	}
+	ans := search(0, l, 1)
+	if ans == -1 {
+		return search(l+1, n-1, -1)
+	}
+	return ans
+}
+```
 
+### **TypeScript**
+
+```ts
+/**
+ * // This is the MountainArray's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * class Master {
+ *      get(index: number): number {}
+ *
+ *      length(): number {}
+ * }
+ */
+
+function findInMountainArray(target: number, mountainArr: MountainArray) {
+    const n = mountainArr.length();
+    let l = 0;
+    let r = n - 1;
+    while (l < r) {
+        const mid = (l + r) >> 1;
+        if (mountainArr.get(mid) > mountainArr.get(mid + 1)) {
+            r = mid;
+        } else {
+            l = mid + 1;
+        }
+    }
+    const search = (l: number, r: number, k: number): number => {
+        while (l < r) {
+            const mid = (l + r) >> 1;
+            if (k * mountainArr.get(mid) >= k * target) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        }
+        return mountainArr.get(l) === target ? l : -1;
+    };
+    const ans = search(0, l, 1);
+    return ans === -1 ? search(l + 1, n - 1, -1) : ans;
+}
 ```
 
 ### **...**