Skip to content

feat: update solutions to lc problem: No.436 #3030

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Jun 4, 2024
Merged

feat: update solutions to lc problem: No.436 #3030

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
144 changes: 59 additions & 85 deletions solution/0400-0499/0436.Find Right Interval/README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -69,7 +69,11 @@ tags:

<!-- solution:start -->

### 方法一：二分查找
### 方法一：排序 + 二分查找

我们可以将区间的起点和下标存入数组 `arr` 中，并按照起点进行排序。然后遍历区间数组，对于每个区间 `[_, ed]`，我们可以使用二分查找找到第一个起点大于等于 `ed` 的区间，即为其右侧区间，如果找到了，我们就将其下标存入答案数组中，否则存入 `-1`。

时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 为区间的长度。

<!-- tabs:start -->

Expand All @@ -78,15 +82,13 @@ tags:
```python
class Solution:
def findRightInterval(self, intervals: List[List[int]]) -> List[int]:
for i, v in enumerate(intervals):
v.append(i)
intervals.sort()
n = len(intervals)
ans = [-1] * n
for _, e, i in intervals:
j = bisect_left(intervals, [e])
arr = sorted((st, i) for i, (st, _) in enumerate(intervals))
for i, (_, ed) in enumerate(intervals):
j = bisect_left(arr, (ed, -inf))
if j < n:
ans[i] = intervals[j][2]
ans[i] = arr[j][1]
return ans
```

Expand All @@ -96,27 +98,30 @@ class Solution:
class Solution {
public int[] findRightInterval(int[][] intervals) {
int n = intervals.length;
List<int[]> starts = new ArrayList<>();
int[][] arr = new int[n][0];
for (int i = 0; i < n; ++i) {
arr[i] = new int[] {intervals[i][0], i};
}
Arrays.sort(arr, (a, b) -> a[0] - b[0]);
int[] ans = new int[n];
for (int i = 0; i < n; ++i) {
starts.add(new int[] {intervals[i][0], i});
int j = search(arr, intervals[i][1]);
ans[i] = j < n ? arr[j][1] : -1;
}
starts.sort(Comparator.comparingInt(a -> a[0]));
int[] res = new int[n];
int i = 0;
for (int[] interval : intervals) {
int left = 0, right = n - 1;
int end = interval[1];
while (left < right) {
int mid = (left + right) >> 1;
if (starts.get(mid)[0] >= end) {
right = mid;
} else {
left = mid + 1;
}
return ans;
}

private int search(int[][] arr, int x) {
int l = 0, r = arr.length;
while (l < r) {
int mid = (l + r) >> 1;
if (arr[mid][0] >= x) {
r = mid;
} else {
l = mid + 1;
}
res[i++] = starts.get(left)[0] < end ? -1 : starts.get(left)[1];
}
return res;
return l;
}
}
```
Expand All @@ -128,61 +133,39 @@ class Solution {
public:
vector<int> findRightInterval(vector<vector<int>>& intervals) {
int n = intervals.size();
vector<pair<int, int>> starts;
vector<pair<int, int>> arr;
for (int i = 0; i < n; ++i) {
starts.emplace_back(make_pair(intervals[i][0], i));
arr.emplace_back(intervals[i][0], i);
}
sort(starts.begin(), starts.end());
vector<int> res;
for (auto interval : intervals) {
int left = 0, right = n - 1;
int end = interval[1];
while (left < right) {
int mid = left + right >> 1;
if (starts[mid].first >= end)
right = mid;
else
left = mid + 1;
}
res.push_back(starts[left].first < end ? -1 : starts[left].second);
sort(arr.begin(), arr.end());
vector<int> ans;
for (auto& e : intervals) {
int j = lower_bound(arr.begin(), arr.end(), make_pair(e[1], -1)) - arr.begin();
ans.push_back(j == n ? -1 : arr[j].second);
}
return res;
return ans;
}
};
```

#### Go

```go
func findRightInterval(intervals [][]int) []int {
n := len(intervals)
starts := make([][]int, n)
for i := 0; i < n; i++ {
starts[i] = make([]int, 2)
starts[i][0] = intervals[i][0]
starts[i][1] = i
func findRightInterval(intervals [][]int) (ans []int) {
arr := make([][2]int, len(intervals))
for i, v := range intervals {
arr[i] = [2]int{v[0], i}
}
sort.Slice(starts, func(i, j int) bool {
return starts[i][0] < starts[j][0]
})
var res []int
for _, interval := range intervals {
left, right, end := 0, n-1, interval[1]
for left < right {
mid := (left + right) >> 1
if starts[mid][0] >= end {
right = mid
} else {
left = mid + 1
}
}
val := -1
if starts[left][0] >= end {
val = starts[left][1]
sort.Slice(arr, func(i, j int) bool { return arr[i][0] < arr[j][0] })
for _, e := range intervals {
j := sort.Search(len(arr), func(i int) bool { return arr[i][0] >= e[1] })
if j < len(arr) {
ans = append(ans, arr[j][1])
} else {
ans = append(ans, -1)
}
res = append(res, val)
}
return res
return
}
```

Expand All @@ -191,28 +174,19 @@ func findRightInterval(intervals [][]int) []int {
```ts
function findRightInterval(intervals: number[][]): number[] {
const n = intervals.length;
const starts = Array.from({ length: n }).map(() => new Array<number>(2));
for (let i = 0; i < n; i++) {
starts[i][0] = intervals[i][0];
starts[i][1] = i;
}
starts.sort((a, b) => a[0] - b[0]);

return intervals.map(([_, target]) => {
let left = 0;
let right = n;
while (left < right) {
const mid = (left + right) >>> 1;
if (starts[mid][0] < target) {
left = mid + 1;
const arr: number[][] = Array.from({ length: n }, (_, i) => [intervals[i][0], i]);
arr.sort((a, b) => a[0] - b[0]);
return intervals.map(([_, ed]) => {
let [l, r] = [0, n];
while (l < r) {
const mid = (l + r) >> 1;
if (arr[mid][0] >= ed) {
r = mid;
} else {
right = mid;
l = mid + 1;
}
}
if (left >= n) {
return -1;
}
return starts[left][1];
return l < n ? arr[l][1] : -1;
});
}
```
Expand Down
Loading
Loading