diff --git a/solution/3600-3699/3633.Earliest Finish Time for Land and Water Rides I/README.md b/solution/3600-3699/3633.Earliest Finish Time for Land and Water Rides I/README.md index d3409ce5c7461..12d29540153b6 100644 --- a/solution/3600-3699/3633.Earliest Finish Time for Land and Water Rides I/README.md +++ b/solution/3600-3699/3633.Earliest Finish Time for Land and Water Rides I/README.md @@ -128,32 +128,129 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3600-3699/3633.Ea -### 方法一 +### 方法一：枚举 + 贪心 + +我们可以考虑两种游乐设施的顺序，先玩陆地游乐设施再玩水上游乐设施，或者先玩水上游乐设施再玩陆地游乐设施。 + +对于每种顺序，我们先计算出第一种游乐设施的最早结束时间 $\textit{minEnd}$，然后枚举第二种游乐设施，计算出第二种游乐设施的最早结束时间 $\max(\textit{minEnd}, \textit{startTime}) + \textit{duration}$，其中 $\textit{startTime}$ 是第二种游乐设施的开始时间。我们取所有可能的最早结束时间的最小值作为答案。 + +最后，我们返回两种顺序的答案中的最小值。 + +时间复杂度 $O(n + m)$，其中 $n$ 和 $m$ 分别是陆地游乐设施和水上游乐设施的数量。空间复杂度 $O(1)$。 #### Python3 ```python - +class Solution: + def earliestFinishTime(self, landStartTime: List[int], landDuration: List[int], waterStartTime: List[int], waterDuration: List[int]) -> int: + def calc(a1, t1, a2, t2): + min_end = min(a + t for a, t in zip(a1, t1)) + return min(max(a, min_end) + t for a, t in zip(a2, t2)) + + x = calc(landStartTime, landDuration, waterStartTime, waterDuration) + y = calc(waterStartTime, waterDuration, landStartTime, landDuration) + return min(x, y) ``` #### Java ```java - +class Solution { + public int earliestFinishTime( + int[] landStartTime, int[] landDuration, int[] waterStartTime, int[] waterDuration) { + int x = calc(landStartTime, landDuration, waterStartTime, waterDuration); + int y = calc(waterStartTime, waterDuration, landStartTime, landDuration); + return Math.min(x, y); + } + + private int calc(int[] a1, int[] t1, int[] a2, int[] t2) { + int minEnd = Integer.MAX_VALUE; + for (int i = 0; i < a1.length; ++i) { + minEnd = Math.min(minEnd, a1[i] + t1[i]); + } + int ans = Integer.MAX_VALUE; + for (int i = 0; i < a2.length; ++i) { + ans = Math.min(ans, Math.max(minEnd, a2[i]) + t2[i]); + } + return ans; + } +} ``` #### C++ ```cpp - +class Solution { +public: + int earliestFinishTime(vector& landStartTime, vector& landDuration, vector& waterStartTime, vector& waterDuration) { + int x = calc(landStartTime, landDuration, waterStartTime, waterDuration); + int y = calc(waterStartTime, waterDuration, landStartTime, landDuration); + return min(x, y); + } + + int calc(vector& a1, vector& t1, vector& a2, vector& t2) { + int minEnd = INT_MAX; + for (int i = 0; i < a1.size(); ++i) { + minEnd = min(minEnd, a1[i] + t1[i]); + } + int ans = INT_MAX; + for (int i = 0; i < a2.size(); ++i) { + ans = min(ans, max(minEnd, a2[i]) + t2[i]); + } + return ans; + } +}; ``` #### Go ```go +func earliestFinishTime(landStartTime []int, landDuration []int, waterStartTime []int, waterDuration []int) int { + x := calc(landStartTime, landDuration, waterStartTime, waterDuration) + y := calc(waterStartTime, waterDuration, landStartTime, landDuration) + return min(x, y) +} + +func calc(a1 []int, t1 []int, a2 []int, t2 []int) int { + minEnd := math.MaxInt32 + for i := 0; i < len(a1); i++ { + minEnd = min(minEnd, a1[i]+t1[i]) + } + ans := math.MaxInt32 + for i := 0; i < len(a2); i++ { + ans = min(ans, max(minEnd, a2[i])+t2[i]) + } + return ans +} +``` +#### TypeScript + +```ts +function earliestFinishTime( + landStartTime: number[], + landDuration: number[], + waterStartTime: number[], + waterDuration: number[], +): number { + const x = calc(landStartTime, landDuration, waterStartTime, waterDuration); + const y = calc(waterStartTime, waterDuration, landStartTime, landDuration); + return Math.min(x, y); +} + +function calc(a1: number[], t1: number[], a2: number[], t2: number[]): number { + let minEnd = Number.MAX_SAFE_INTEGER; + for (let i = 0; i < a1.length; i++) { + minEnd = Math.min(minEnd, a1[i] + t1[i]); + } + let ans = Number.MAX_SAFE_INTEGER; + for (let i = 0; i < a2.length; i++) { + ans = Math.min(ans, Math.max(minEnd, a2[i]) + t2[i]); + } + return ans; +} ``` diff --git a/solution/3600-3699/3633.Earliest Finish Time for Land and Water Rides I/README_EN.md b/solution/3600-3699/3633.Earliest Finish Time for Land and Water Rides I/README_EN.md index 46988e23185cf..3aa6c3401305c 100644 --- a/solution/3600-3699/3633.Earliest Finish Time for Land and Water Rides I/README_EN.md +++ b/solution/3600-3699/3633.Earliest Finish Time for Land and Water Rides I/README_EN.md @@ -126,32 +126,129 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3600-3699/3633.Ea -### Solution 1 +### Solution 1: Enumeration + Greedy + +We can consider two orders of rides: first land rides then water rides, or first water rides then land rides. + +For each order, we first calculate the earliest end time $\textit{minEnd}$ of the first type of ride, then enumerate the second type of ride and calculate the earliest end time of the second type of ride as $\max(\textit{minEnd}, \textit{startTime}) + \textit{duration}$, where $\textit{startTime}$ is the start time of the second type of ride. We take the minimum value among all possible earliest end times as the answer. + +Finally, we return the minimum value between the answers of the two orders. + +The time complexity is $O(n + m)$, where $n$ and $m$ are the numbers of land rides and water rides respectively. The space complexity is $O(1)$. #### Python3 ```python - +class Solution: + def earliestFinishTime(self, landStartTime: List[int], landDuration: List[int], waterStartTime: List[int], waterDuration: List[int]) -> int: + def calc(a1, t1, a2, t2): + min_end = min(a + t for a, t in zip(a1, t1)) + return min(max(a, min_end) + t for a, t in zip(a2, t2)) + + x = calc(landStartTime, landDuration, waterStartTime, waterDuration) + y = calc(waterStartTime, waterDuration, landStartTime, landDuration) + return min(x, y) ``` #### Java ```java - +class Solution { + public int earliestFinishTime( + int[] landStartTime, int[] landDuration, int[] waterStartTime, int[] waterDuration) { + int x = calc(landStartTime, landDuration, waterStartTime, waterDuration); + int y = calc(waterStartTime, waterDuration, landStartTime, landDuration); + return Math.min(x, y); + } + + private int calc(int[] a1, int[] t1, int[] a2, int[] t2) { + int minEnd = Integer.MAX_VALUE; + for (int i = 0; i < a1.length; ++i) { + minEnd = Math.min(minEnd, a1[i] + t1[i]); + } + int ans = Integer.MAX_VALUE; + for (int i = 0; i < a2.length; ++i) { + ans = Math.min(ans, Math.max(minEnd, a2[i]) + t2[i]); + } + return ans; + } +} ``` #### C++ ```cpp - +class Solution { +public: + int earliestFinishTime(vector& landStartTime, vector& landDuration, vector& waterStartTime, vector& waterDuration) { + int x = calc(landStartTime, landDuration, waterStartTime, waterDuration); + int y = calc(waterStartTime, waterDuration, landStartTime, landDuration); + return min(x, y); + } + + int calc(vector& a1, vector& t1, vector& a2, vector& t2) { + int minEnd = INT_MAX; + for (int i = 0; i < a1.size(); ++i) { + minEnd = min(minEnd, a1[i] + t1[i]); + } + int ans = INT_MAX; + for (int i = 0; i < a2.size(); ++i) { + ans = min(ans, max(minEnd, a2[i]) + t2[i]); + } + return ans; + } +}; ``` #### Go ```go +func earliestFinishTime(landStartTime []int, landDuration []int, waterStartTime []int, waterDuration []int) int { + x := calc(landStartTime, landDuration, waterStartTime, waterDuration) + y := calc(waterStartTime, waterDuration, landStartTime, landDuration) + return min(x, y) +} + +func calc(a1 []int, t1 []int, a2 []int, t2 []int) int { + minEnd := math.MaxInt32 + for i := 0; i < len(a1); i++ { + minEnd = min(minEnd, a1[i]+t1[i]) + } + ans := math.MaxInt32 + for i := 0; i < len(a2); i++ { + ans = min(ans, max(minEnd, a2[i])+t2[i]) + } + return ans +} +``` +#### TypeScript + +```ts +function earliestFinishTime( + landStartTime: number[], + landDuration: number[], + waterStartTime: number[], + waterDuration: number[], +): number { + const x = calc(landStartTime, landDuration, waterStartTime, waterDuration); + const y = calc(waterStartTime, waterDuration, landStartTime, landDuration); + return Math.min(x, y); +} + +function calc(a1: number[], t1: number[], a2: number[], t2: number[]): number { + let minEnd = Number.MAX_SAFE_INTEGER; + for (let i = 0; i < a1.length; i++) { + minEnd = Math.min(minEnd, a1[i] + t1[i]); + } + let ans = Number.MAX_SAFE_INTEGER; + for (let i = 0; i < a2.length; i++) { + ans = Math.min(ans, Math.max(minEnd, a2[i]) + t2[i]); + } + return ans; +} ``` diff --git a/solution/3600-3699/3633.Earliest Finish Time for Land and Water Rides I/Solution.cpp b/solution/3600-3699/3633.Earliest Finish Time for Land and Water Rides I/Solution.cpp new file mode 100644 index 0000000000000..8df44a9aa1070 --- /dev/null +++ b/solution/3600-3699/3633.Earliest Finish Time for Land and Water Rides I/Solution.cpp @@ -0,0 +1,20 @@ +class Solution { +public: + int earliestFinishTime(vector& landStartTime, vector& landDuration, vector& waterStartTime, vector& waterDuration) { + int x = calc(landStartTime, landDuration, waterStartTime, waterDuration); + int y = calc(waterStartTime, waterDuration, landStartTime, landDuration); + return min(x, y); + } + + int calc(vector& a1, vector& t1, vector& a2, vector& t2) { + int minEnd = INT_MAX; + for (int i = 0; i < a1.size(); ++i) { + minEnd = min(minEnd, a1[i] + t1[i]); + } + int ans = INT_MAX; + for (int i = 0; i < a2.size(); ++i) { + ans = min(ans, max(minEnd, a2[i]) + t2[i]); + } + return ans; + } +}; diff --git a/solution/3600-3699/3633.Earliest Finish Time for Land and Water Rides I/Solution.go b/solution/3600-3699/3633.Earliest Finish Time for Land and Water Rides I/Solution.go new file mode 100644 index 0000000000000..2dc76cf0d48e2 --- /dev/null +++ b/solution/3600-3699/3633.Earliest Finish Time for Land and Water Rides I/Solution.go @@ -0,0 +1,17 @@ +func earliestFinishTime(landStartTime []int, landDuration []int, waterStartTime []int, waterDuration []int) int { + x := calc(landStartTime, landDuration, waterStartTime, waterDuration) + y := calc(waterStartTime, waterDuration, landStartTime, landDuration) + return min(x, y) +} + +func calc(a1 []int, t1 []int, a2 []int, t2 []int) int { + minEnd := math.MaxInt32 + for i := 0; i < len(a1); i++ { + minEnd = min(minEnd, a1[i]+t1[i]) + } + ans := math.MaxInt32 + for i := 0; i < len(a2); i++ { + ans = min(ans, max(minEnd, a2[i])+t2[i]) + } + return ans +} diff --git a/solution/3600-3699/3633.Earliest Finish Time for Land and Water Rides I/Solution.java b/solution/3600-3699/3633.Earliest Finish Time for Land and Water Rides I/Solution.java new file mode 100644 index 0000000000000..0c21380fd8e7d --- /dev/null +++ b/solution/3600-3699/3633.Earliest Finish Time for Land and Water Rides I/Solution.java @@ -0,0 +1,20 @@ +class Solution { + public int earliestFinishTime( + int[] landStartTime, int[] landDuration, int[] waterStartTime, int[] waterDuration) { + int x = calc(landStartTime, landDuration, waterStartTime, waterDuration); + int y = calc(waterStartTime, waterDuration, landStartTime, landDuration); + return Math.min(x, y); + } + + private int calc(int[] a1, int[] t1, int[] a2, int[] t2) { + int minEnd = Integer.MAX_VALUE; + for (int i = 0; i < a1.length; ++i) { + minEnd = Math.min(minEnd, a1[i] + t1[i]); + } + int ans = Integer.MAX_VALUE; + for (int i = 0; i < a2.length; ++i) { + ans = Math.min(ans, Math.max(minEnd, a2[i]) + t2[i]); + } + return ans; + } +} diff --git a/solution/3600-3699/3633.Earliest Finish Time for Land and Water Rides I/Solution.py b/solution/3600-3699/3633.Earliest Finish Time for Land and Water Rides I/Solution.py new file mode 100644 index 0000000000000..d461509ae4af8 --- /dev/null +++ b/solution/3600-3699/3633.Earliest Finish Time for Land and Water Rides I/Solution.py @@ -0,0 +1,15 @@ +class Solution: + def earliestFinishTime( + self, + landStartTime: List[int], + landDuration: List[int], + waterStartTime: List[int], + waterDuration: List[int], + ) -> int: + def calc(a1, t1, a2, t2): + min_end = min(a + t for a, t in zip(a1, t1)) + return min(max(a, min_end) + t for a, t in zip(a2, t2)) + + x = calc(landStartTime, landDuration, waterStartTime, waterDuration) + y = calc(waterStartTime, waterDuration, landStartTime, landDuration) + return min(x, y) diff --git a/solution/3600-3699/3633.Earliest Finish Time for Land and Water Rides I/Solution.ts b/solution/3600-3699/3633.Earliest Finish Time for Land and Water Rides I/Solution.ts new file mode 100644 index 0000000000000..0a1aafd306bed --- /dev/null +++ b/solution/3600-3699/3633.Earliest Finish Time for Land and Water Rides I/Solution.ts @@ -0,0 +1,22 @@ +function earliestFinishTime( + landStartTime: number[], + landDuration: number[], + waterStartTime: number[], + waterDuration: number[], +): number { + const x = calc(landStartTime, landDuration, waterStartTime, waterDuration); + const y = calc(waterStartTime, waterDuration, landStartTime, landDuration); + return Math.min(x, y); +} + +function calc(a1: number[], t1: number[], a2: number[], t2: number[]): number { + let minEnd = Number.MAX_SAFE_INTEGER; + for (let i = 0; i < a1.length; i++) { + minEnd = Math.min(minEnd, a1[i] + t1[i]); + } + let ans = Number.MAX_SAFE_INTEGER; + for (let i = 0; i < a2.length; i++) { + ans = Math.min(ans, Math.max(minEnd, a2[i]) + t2[i]); + } + return ans; +} diff --git a/solution/3600-3699/3635.Earliest Finish Time for Land and Water Rides II/README.md b/solution/3600-3699/3635.Earliest Finish Time for Land and Water Rides II/README.md index f6e6dd0064c02..6ed3932715dea 100644 --- a/solution/3600-3699/3635.Earliest Finish Time for Land and Water Rides II/README.md +++ b/solution/3600-3699/3635.Earliest Finish Time for Land and Water Rides II/README.md @@ -129,32 +129,129 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3600-3699/3635.Ea -### 方法一 +### 方法一：枚举 + 贪心 + +我们可以考虑两种游乐设施的顺序，先玩陆地游乐设施再玩水上游乐设施，或者先玩水上游乐设施再玩陆地游乐设施。 + +对于每种顺序，我们先计算出第一种游乐设施的最早结束时间 $\textit{minEnd}$，然后枚举第二种游乐设施，计算出第二种游乐设施的最早结束时间 $\max(\textit{minEnd}, \textit{startTime}) + \textit{duration}$，其中 $\textit{startTime}$ 是第二种游乐设施的开始时间。我们取所有可能的最早结束时间的最小值作为答案。 + +最后，我们返回两种顺序的答案中的最小值。 + +时间复杂度 $O(n + m)$，其中 $n$ 和 $m$ 分别是陆地游乐设施和水上游乐设施的数量。空间复杂度 $O(1)$。 #### Python3 ```python - +class Solution: + def earliestFinishTime(self, landStartTime: List[int], landDuration: List[int], waterStartTime: List[int], waterDuration: List[int]) -> int: + def calc(a1, t1, a2, t2): + min_end = min(a + t for a, t in zip(a1, t1)) + return min(max(a, min_end) + t for a, t in zip(a2, t2)) + + x = calc(landStartTime, landDuration, waterStartTime, waterDuration) + y = calc(waterStartTime, waterDuration, landStartTime, landDuration) + return min(x, y) ``` #### Java ```java - +class Solution { + public int earliestFinishTime( + int[] landStartTime, int[] landDuration, int[] waterStartTime, int[] waterDuration) { + int x = calc(landStartTime, landDuration, waterStartTime, waterDuration); + int y = calc(waterStartTime, waterDuration, landStartTime, landDuration); + return Math.min(x, y); + } + + private int calc(int[] a1, int[] t1, int[] a2, int[] t2) { + int minEnd = Integer.MAX_VALUE; + for (int i = 0; i < a1.length; ++i) { + minEnd = Math.min(minEnd, a1[i] + t1[i]); + } + int ans = Integer.MAX_VALUE; + for (int i = 0; i < a2.length; ++i) { + ans = Math.min(ans, Math.max(minEnd, a2[i]) + t2[i]); + } + return ans; + } +} ``` #### C++ ```cpp - +class Solution { +public: + int earliestFinishTime(vector& landStartTime, vector& landDuration, vector& waterStartTime, vector& waterDuration) { + int x = calc(landStartTime, landDuration, waterStartTime, waterDuration); + int y = calc(waterStartTime, waterDuration, landStartTime, landDuration); + return min(x, y); + } + + int calc(vector& a1, vector& t1, vector& a2, vector& t2) { + int minEnd = INT_MAX; + for (int i = 0; i < a1.size(); ++i) { + minEnd = min(minEnd, a1[i] + t1[i]); + } + int ans = INT_MAX; + for (int i = 0; i < a2.size(); ++i) { + ans = min(ans, max(minEnd, a2[i]) + t2[i]); + } + return ans; + } +}; ``` #### Go ```go +func earliestFinishTime(landStartTime []int, landDuration []int, waterStartTime []int, waterDuration []int) int { + x := calc(landStartTime, landDuration, waterStartTime, waterDuration) + y := calc(waterStartTime, waterDuration, landStartTime, landDuration) + return min(x, y) +} + +func calc(a1 []int, t1 []int, a2 []int, t2 []int) int { + minEnd := math.MaxInt32 + for i := 0; i < len(a1); i++ { + minEnd = min(minEnd, a1[i]+t1[i]) + } + ans := math.MaxInt32 + for i := 0; i < len(a2); i++ { + ans = min(ans, max(minEnd, a2[i])+t2[i]) + } + return ans +} +``` +#### TypeScript + +```ts +function earliestFinishTime( + landStartTime: number[], + landDuration: number[], + waterStartTime: number[], + waterDuration: number[], +): number { + const x = calc(landStartTime, landDuration, waterStartTime, waterDuration); + const y = calc(waterStartTime, waterDuration, landStartTime, landDuration); + return Math.min(x, y); +} + +function calc(a1: number[], t1: number[], a2: number[], t2: number[]): number { + let minEnd = Number.MAX_SAFE_INTEGER; + for (let i = 0; i < a1.length; i++) { + minEnd = Math.min(minEnd, a1[i] + t1[i]); + } + let ans = Number.MAX_SAFE_INTEGER; + for (let i = 0; i < a2.length; i++) { + ans = Math.min(ans, Math.max(minEnd, a2[i]) + t2[i]); + } + return ans; +} ``` diff --git a/solution/3600-3699/3635.Earliest Finish Time for Land and Water Rides II/README_EN.md b/solution/3600-3699/3635.Earliest Finish Time for Land and Water Rides II/README_EN.md index d22d247e09888..c7bc7cb5fae0d 100644 --- a/solution/3600-3699/3635.Earliest Finish Time for Land and Water Rides II/README_EN.md +++ b/solution/3600-3699/3635.Earliest Finish Time for Land and Water Rides II/README_EN.md @@ -127,32 +127,129 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3600-3699/3635.Ea -### Solution 1 +### Solution 1: Enumeration + Greedy + +We can consider two orders of rides: first land rides then water rides, or first water rides then land rides. + +For each order, we first calculate the earliest end time $\textit{minEnd}$ of the first type of ride, then enumerate the second type of ride and calculate the earliest end time of the second type of ride as $\max(\textit{minEnd}, \textit{startTime}) + \textit{duration}$, where $\textit{startTime}$ is the start time of the second type of ride. We take the minimum value among all possible earliest end times as the answer. + +Finally, we return the minimum value between the answers of the two orders. + +The time complexity is $O(n + m)$, where $n$ and $m$ are the numbers of land rides and water rides respectively. The space complexity is $O(1)$. #### Python3 ```python - +class Solution: + def earliestFinishTime(self, landStartTime: List[int], landDuration: List[int], waterStartTime: List[int], waterDuration: List[int]) -> int: + def calc(a1, t1, a2, t2): + min_end = min(a + t for a, t in zip(a1, t1)) + return min(max(a, min_end) + t for a, t in zip(a2, t2)) + + x = calc(landStartTime, landDuration, waterStartTime, waterDuration) + y = calc(waterStartTime, waterDuration, landStartTime, landDuration) + return min(x, y) ``` #### Java ```java - +class Solution { + public int earliestFinishTime( + int[] landStartTime, int[] landDuration, int[] waterStartTime, int[] waterDuration) { + int x = calc(landStartTime, landDuration, waterStartTime, waterDuration); + int y = calc(waterStartTime, waterDuration, landStartTime, landDuration); + return Math.min(x, y); + } + + private int calc(int[] a1, int[] t1, int[] a2, int[] t2) { + int minEnd = Integer.MAX_VALUE; + for (int i = 0; i < a1.length; ++i) { + minEnd = Math.min(minEnd, a1[i] + t1[i]); + } + int ans = Integer.MAX_VALUE; + for (int i = 0; i < a2.length; ++i) { + ans = Math.min(ans, Math.max(minEnd, a2[i]) + t2[i]); + } + return ans; + } +} ``` #### C++ ```cpp - +class Solution { +public: + int earliestFinishTime(vector& landStartTime, vector& landDuration, vector& waterStartTime, vector& waterDuration) { + int x = calc(landStartTime, landDuration, waterStartTime, waterDuration); + int y = calc(waterStartTime, waterDuration, landStartTime, landDuration); + return min(x, y); + } + + int calc(vector& a1, vector& t1, vector& a2, vector& t2) { + int minEnd = INT_MAX; + for (int i = 0; i < a1.size(); ++i) { + minEnd = min(minEnd, a1[i] + t1[i]); + } + int ans = INT_MAX; + for (int i = 0; i < a2.size(); ++i) { + ans = min(ans, max(minEnd, a2[i]) + t2[i]); + } + return ans; + } +}; ``` #### Go ```go +func earliestFinishTime(landStartTime []int, landDuration []int, waterStartTime []int, waterDuration []int) int { + x := calc(landStartTime, landDuration, waterStartTime, waterDuration) + y := calc(waterStartTime, waterDuration, landStartTime, landDuration) + return min(x, y) +} + +func calc(a1 []int, t1 []int, a2 []int, t2 []int) int { + minEnd := math.MaxInt32 + for i := 0; i < len(a1); i++ { + minEnd = min(minEnd, a1[i]+t1[i]) + } + ans := math.MaxInt32 + for i := 0; i < len(a2); i++ { + ans = min(ans, max(minEnd, a2[i])+t2[i]) + } + return ans +} +``` +#### TypeScript + +```ts +function earliestFinishTime( + landStartTime: number[], + landDuration: number[], + waterStartTime: number[], + waterDuration: number[], +): number { + const x = calc(landStartTime, landDuration, waterStartTime, waterDuration); + const y = calc(waterStartTime, waterDuration, landStartTime, landDuration); + return Math.min(x, y); +} + +function calc(a1: number[], t1: number[], a2: number[], t2: number[]): number { + let minEnd = Number.MAX_SAFE_INTEGER; + for (let i = 0; i < a1.length; i++) { + minEnd = Math.min(minEnd, a1[i] + t1[i]); + } + let ans = Number.MAX_SAFE_INTEGER; + for (let i = 0; i < a2.length; i++) { + ans = Math.min(ans, Math.max(minEnd, a2[i]) + t2[i]); + } + return ans; +} ``` diff --git a/solution/3600-3699/3635.Earliest Finish Time for Land and Water Rides II/Solution.cpp b/solution/3600-3699/3635.Earliest Finish Time for Land and Water Rides II/Solution.cpp new file mode 100644 index 0000000000000..8df44a9aa1070 --- /dev/null +++ b/solution/3600-3699/3635.Earliest Finish Time for Land and Water Rides II/Solution.cpp @@ -0,0 +1,20 @@ +class Solution { +public: + int earliestFinishTime(vector& landStartTime, vector& landDuration, vector& waterStartTime, vector& waterDuration) { + int x = calc(landStartTime, landDuration, waterStartTime, waterDuration); + int y = calc(waterStartTime, waterDuration, landStartTime, landDuration); + return min(x, y); + } + + int calc(vector& a1, vector& t1, vector& a2, vector& t2) { + int minEnd = INT_MAX; + for (int i = 0; i < a1.size(); ++i) { + minEnd = min(minEnd, a1[i] + t1[i]); + } + int ans = INT_MAX; + for (int i = 0; i < a2.size(); ++i) { + ans = min(ans, max(minEnd, a2[i]) + t2[i]); + } + return ans; + } +}; diff --git a/solution/3600-3699/3635.Earliest Finish Time for Land and Water Rides II/Solution.go b/solution/3600-3699/3635.Earliest Finish Time for Land and Water Rides II/Solution.go new file mode 100644 index 0000000000000..2dc76cf0d48e2 --- /dev/null +++ b/solution/3600-3699/3635.Earliest Finish Time for Land and Water Rides II/Solution.go @@ -0,0 +1,17 @@ +func earliestFinishTime(landStartTime []int, landDuration []int, waterStartTime []int, waterDuration []int) int { + x := calc(landStartTime, landDuration, waterStartTime, waterDuration) + y := calc(waterStartTime, waterDuration, landStartTime, landDuration) + return min(x, y) +} + +func calc(a1 []int, t1 []int, a2 []int, t2 []int) int { + minEnd := math.MaxInt32 + for i := 0; i < len(a1); i++ { + minEnd = min(minEnd, a1[i]+t1[i]) + } + ans := math.MaxInt32 + for i := 0; i < len(a2); i++ { + ans = min(ans, max(minEnd, a2[i])+t2[i]) + } + return ans +} diff --git a/solution/3600-3699/3635.Earliest Finish Time for Land and Water Rides II/Solution.java b/solution/3600-3699/3635.Earliest Finish Time for Land and Water Rides II/Solution.java new file mode 100644 index 0000000000000..0c21380fd8e7d --- /dev/null +++ b/solution/3600-3699/3635.Earliest Finish Time for Land and Water Rides II/Solution.java @@ -0,0 +1,20 @@ +class Solution { + public int earliestFinishTime( + int[] landStartTime, int[] landDuration, int[] waterStartTime, int[] waterDuration) { + int x = calc(landStartTime, landDuration, waterStartTime, waterDuration); + int y = calc(waterStartTime, waterDuration, landStartTime, landDuration); + return Math.min(x, y); + } + + private int calc(int[] a1, int[] t1, int[] a2, int[] t2) { + int minEnd = Integer.MAX_VALUE; + for (int i = 0; i < a1.length; ++i) { + minEnd = Math.min(minEnd, a1[i] + t1[i]); + } + int ans = Integer.MAX_VALUE; + for (int i = 0; i < a2.length; ++i) { + ans = Math.min(ans, Math.max(minEnd, a2[i]) + t2[i]); + } + return ans; + } +} diff --git a/solution/3600-3699/3635.Earliest Finish Time for Land and Water Rides II/Solution.py b/solution/3600-3699/3635.Earliest Finish Time for Land and Water Rides II/Solution.py new file mode 100644 index 0000000000000..d461509ae4af8 --- /dev/null +++ b/solution/3600-3699/3635.Earliest Finish Time for Land and Water Rides II/Solution.py @@ -0,0 +1,15 @@ +class Solution: + def earliestFinishTime( + self, + landStartTime: List[int], + landDuration: List[int], + waterStartTime: List[int], + waterDuration: List[int], + ) -> int: + def calc(a1, t1, a2, t2): + min_end = min(a + t for a, t in zip(a1, t1)) + return min(max(a, min_end) + t for a, t in zip(a2, t2)) + + x = calc(landStartTime, landDuration, waterStartTime, waterDuration) + y = calc(waterStartTime, waterDuration, landStartTime, landDuration) + return min(x, y) diff --git a/solution/3600-3699/3635.Earliest Finish Time for Land and Water Rides II/Solution.ts b/solution/3600-3699/3635.Earliest Finish Time for Land and Water Rides II/Solution.ts new file mode 100644 index 0000000000000..0a1aafd306bed --- /dev/null +++ b/solution/3600-3699/3635.Earliest Finish Time for Land and Water Rides II/Solution.ts @@ -0,0 +1,22 @@ +function earliestFinishTime( + landStartTime: number[], + landDuration: number[], + waterStartTime: number[], + waterDuration: number[], +): number { + const x = calc(landStartTime, landDuration, waterStartTime, waterDuration); + const y = calc(waterStartTime, waterDuration, landStartTime, landDuration); + return Math.min(x, y); +} + +function calc(a1: number[], t1: number[], a2: number[], t2: number[]): number { + let minEnd = Number.MAX_SAFE_INTEGER; + for (let i = 0; i < a1.length; i++) { + minEnd = Math.min(minEnd, a1[i] + t1[i]); + } + let ans = Number.MAX_SAFE_INTEGER; + for (let i = 0; i < a2.length; i++) { + ans = Math.min(ans, Math.max(minEnd, a2[i]) + t2[i]); + } + return ans; +}