1class Solution {
2    /**
3     * Calculates the earliest time all land and water tasks can be finished,
4     * considering both orders: land-then-water and water-then-land
5     *
6     * @param landStartTime Array of start times for land tasks
7     * @param landDuration Array of durations for land tasks
8     * @param waterStartTime Array of start times for water tasks
9     * @param waterDuration Array of durations for water tasks
10     * @return The earliest finish time by considering both task orders
11     */
12    public int earliestFinishTime(
13        int[] landStartTime, int[] landDuration, int[] waterStartTime, int[] waterDuration) {
14        // Calculate finish time: finish all land first, then water
15        int finishLandFirst = calc(landStartTime, landDuration, waterStartTime, waterDuration);
16        // Calculate finish time: finish all water first, then land
17        int finishWaterFirst = calc(waterStartTime, waterDuration, landStartTime, landDuration);
18        // Return the minimum of the two approaches
19        return Math.min(finishLandFirst, finishWaterFirst);
20    }
21
22    /**
23     * Helper method to compute the finish time for one order of tasks.
24     * For (firstStart, firstDur, secondStart, secondDur), this finds the earliest
25     * time all first-tasks can finish, then schedules each second-task after that.
26     *
27     * @param firstStart Array of start times for first group of tasks
28     * @param firstDur Array of durations for first group of tasks
29     * @param secondStart Array of start times for second group of tasks
30     * @param secondDur Array of durations for second group of tasks
31     * @return The earliest finish time for this schedule order
32     */
33    private int calc(int[] firstStart, int[] firstDur, int[] secondStart, int[] secondDur) {
34        // Find the finishing time after all first group tasks are done
35        int minEndFirst = Integer.MAX_VALUE;
36        for (int i = 0; i < firstStart.length; ++i) {
37            // Completion time for each first-group task
38            minEndFirst = Math.min(minEndFirst, firstStart[i] + firstDur[i]);
39        }
40
41        // Determine the minimum finish time for second group tasks
42        int minFinish = Integer.MAX_VALUE;
43        for (int i = 0; i < secondStart.length; ++i) {
44            // Start the second-group task when both groups are ready, and add its duration
45            int start = Math.max(minEndFirst, secondStart[i]);
46            minFinish = Math.min(minFinish, start + secondDur[i]);
47        }
48        return minFinish;
49    }
50}
51

1#include <vector>
2#include <climits>
3#include <algorithm>
4using namespace std;
5
6class Solution {
7public:
8    // Returns the minimal finish time by trying both possible orders:
9    // (1) Do all land tasks first, then water tasks.
10    // (2) Do all water tasks first, then land tasks.
11    int earliestFinishTime(vector<int>& landStartTime, vector<int>& landDuration, vector<int>& waterStartTime, vector<int>& waterDuration) {
12        // Try both orders and return the minimum finish time
13        int finishTimeByLandFirst = calc(landStartTime, landDuration, waterStartTime, waterDuration);
14        int finishTimeByWaterFirst = calc(waterStartTime, waterDuration, landStartTime, landDuration);
15        return min(finishTimeByLandFirst, finishTimeByWaterFirst);
16    }
17
18    // Calculates the earliest finish time if group1 tasks are done first, then group2 tasks.
19    int calc(vector<int>& group1Start, vector<int>& group1Duration,
20             vector<int>& group2Start, vector<int>& group2Duration) {
21        // Find the time when the last group1 task finishes.
22        int group1Finish = INT_MAX;
23        for (int i = 0; i < group1Start.size(); ++i) {
24            group1Finish = min(group1Finish, group1Start[i] + group1Duration[i]);
25        }
26        // For each group2 task, compute the earliest it can start (after group1 is done) and finish.
27        int minTotalFinish = INT_MAX;
28        for (int i = 0; i < group2Start.size(); ++i) {
29            int group2ActualStart = max(group1Finish, group2Start[i]);
30            int group2Finish = group2ActualStart + group2Duration[i];
31            minTotalFinish = min(minTotalFinish, group2Finish);
32        }
33        return minTotalFinish;
34    }
35};
36

1/**
2 * Calculates the earliest finish time by considering starting on land first or water first.
3 * Evaluates both routes and returns the minimal possible finish time.
4 *
5 * @param landStartTime - Array of start times for land segments.
6 * @param landDuration - Array of durations for land segments.
7 * @param waterStartTime - Array of start times for water segments.
8 * @param waterDuration - Array of durations for water segments.
9 * @returns The earliest finish time possible by alternating land and water sequences.
10 */
11function earliestFinishTime(
12    landStartTime: number[],
13    landDuration: number[],
14    waterStartTime: number[],
15    waterDuration: number[],
16): number {
17    // Try starting with land, then water
18    const finishWithLandFirst = calc(landStartTime, landDuration, waterStartTime, waterDuration);
19    // Try starting with water, then land
20    const finishWithWaterFirst = calc(waterStartTime, waterDuration, landStartTime, landDuration);
21    // Return the minimal finish among the two alternatives
22    return Math.min(finishWithLandFirst, finishWithWaterFirst);
23}
24
25/**
26 * Helper function to calculate finish time for a particular order of activities.
27 *
28 * @param firstStart - Array of start times for the first set of segments (either land or water).
29 * @param firstDuration - Array of durations for the first set of segments.
30 * @param secondStart - Array of start times for the second set of segments.
31 * @param secondDuration - Array of durations for the second set of segments.
32 * @returns The earliest possible finish time for the given order.
33 */
34function calc(
35    firstStart: number[],
36    firstDuration: number[],
37    secondStart: number[],
38    secondDuration: number[]
39): number {
40    // Find the earliest possible end time after finishing all "first" segments
41    let minFirstEnd = Number.MAX_SAFE_INTEGER;
42    for (let i = 0; i < firstStart.length; i++) {
43        minFirstEnd = Math.min(minFirstEnd, firstStart[i] + firstDuration[i]);
44    }
45    // Try all second segments as possible next activities
46    let minTotalEnd = Number.MAX_SAFE_INTEGER;
47    for (let i = 0; i < secondStart.length; i++) {
48        // Start second segment after finishing first, but cannot start before its own available time
49        const secondStartTime = Math.max(minFirstEnd, secondStart[i]);
50        minTotalEnd = Math.min(minTotalEnd, secondStartTime + secondDuration[i]);
51    }
52    // Return the minimal overall finish time
53    return minTotalEnd;
54}
55