Given an array of distinct integers arr, where arr is sorted in ascending order , return the smallest index i that satisfies arr[i] == i. If there is no such index, return -1.
Check the middle element (mid = (start + end) / 2) and compares it to its index in nums[mid]. If they are equal (nums[mid] == mid), return mid as fixed point.
If the middle element is greater than its index search the fixed point in the right half of array
Conversely, if the middle element is less than its index search the fixed point might be in the left half
Lets analyze case in point 2 in algorithm when mid > nums[mid].
We know the array nums is sorted and the function f(x) is increasing (meaning f(x) > f(y) for x > y).
When mid > nums[mid] , for eg. mid = 4, nums[mid] = 3… searching in left subarray will be useless, because mid will always be more than nums[mid] as elements are distinct. So, we just go to right subarray.
Similarly, when mid < nums[mid], for eg. mid = 4, nums[2] = 6, searching in right subarray will be useless, as mid will never be able to catch up with the nums[i] values. So, we can only go to left subarray.
Because of choosing just 1 path to find the answer, binary search.
While left <= right:
- Compute mid = (left + right) // 2.
- If arr[mid] < mid, search right half (left = mid + 1).
- If arr[mid] > mid, search left half (right = mid - 1).
- If arr[mid] == mid, record mid as a candidate and continue searching left half for a smaller index.
Return the smallest index found, or -1 if none exists.
classSolution {
public:int fixedPoint(vector<int>& arr) {
int l =0, r = arr.size() -1, ans =-1;
while (l <= r) {
int m = l + (r - l) /2;
if (arr[m] == m) {
ans = m;
r = m -1;
} elseif (arr[m] < m) {
l = m +1;
} else {
r = m -1;
}
}
return ans;
}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
funcfixedPoint(arr []int) int {
l, r, ans:=0, len(arr)-1, -1forl<=r {
m:= (l+r) /2ifarr[m] ==m {
ans = mr = m-1 } elseifarr[m] < m {
l = m+1 } else {
r = m-1 }
}
returnans}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
classSolution {
publicintfixedPoint(int[] arr) {
int l = 0, r = arr.length- 1, ans =-1;
while (l <= r) {
int m = l + (r - l) / 2;
if (arr[m]== m) {
ans = m;
r = m - 1;
} elseif (arr[m]< m) {
l = m + 1;
} else {
r = m - 1;
}
}
return ans;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
classSolution {
funfixedPoint(arr: IntArray): Int {
var l = 0var r = arr.size - 1var ans = -1while (l <= r) {
val m = (l + r) / 2if (arr[m] == m) {
ans = m
r = m - 1 } elseif (arr[m] < m) {
l = m + 1 } else {
r = m - 1 }
}
return ans
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
classSolution:
deffixedPoint(self, arr: list[int]) -> int:
l, r, ans =0, len(arr) -1, -1while l <= r:
m = (l + r) //2if arr[m] == m:
ans = m
r = m -1elif arr[m] < m:
l = m +1else:
r = m -1return ans
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
impl Solution {
pubfnfixed_point(arr: Vec<i32>) -> i32 {
let (mut l, mut r, mut ans) = (0, arr.len() asi32-1, -1);
while l <= r {
let m = (l + r) /2;
let m_usize = m asusize;
if arr[m_usize] == m {
ans = m;
r = m -1;
} elseif arr[m_usize] < m {
l = m +1;
} else {
r = m -1;
}
}
ans
}
}