feat: add solutions to lc problem: No.2534

No.2534.Time Taken to Cross the Door

Author: yanglbme

solution/2500-2599/2532.Time to Cross a Bridge/README_EN.md

@@ -107,7 +107,30 @@ From 49 to 50: worker 0 crosses the bridge to the left.
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Priority Queue (Max-Heap and Min-Heap) + Simulation
+
+First, we sort the workers by efficiency in descending order, so the worker with the highest index has the lowest efficiency.
+
+Next, we use four priority queues to simulate the state of the workers:
+
+-   `wait_in_left`: Max-heap, storing the indices of workers currently waiting on the left bank;
+-   `wait_in_right`: Max-heap, storing the indices of workers currently waiting on the right bank;
+-   `work_in_left`: Min-heap, storing the time when workers currently working on the left bank finish placing boxes and the indices of the workers;
+-   `work_in_right`: Min-heap, storing the time when workers currently working on the right bank finish picking up boxes and the indices of the workers.
+
+Initially, all workers are on the left bank, so `wait_in_left` stores the indices of all workers. We use the variable `cur` to record the current time.
+
+Then, we simulate the entire process. First, we check if any worker in `work_in_left` has finished placing boxes at the current time. If so, we move the worker to `wait_in_left` and remove the worker from `work_in_left`. Similarly, we check if any worker in `work_in_right` has finished picking up boxes. If so, we move the worker to `wait_in_right` and remove the worker from `work_in_right`.
+
+Next, we check if there are any workers waiting on the left bank at the current time, denoted as `left_to_go`. At the same time, we check if there are any workers waiting on the right bank, denoted as `right_to_go`. If there are no workers waiting to cross the river, we directly update `cur` to the next time when a worker finishes placing boxes and continue the simulation.
+
+If `right_to_go` is `true`, we take a worker from `wait_in_right`, update `cur` to the current time plus the time it takes for the worker to cross from the right bank to the left bank. If all workers have crossed to the right bank at this point, we directly return `cur` as the answer; otherwise, we move the worker to `work_in_left`.
+
+If `left_to_go` is `true`, we take a worker from `wait_in_left`, update `cur` to the current time plus the time it takes for the worker to cross from the left bank to the right bank, then move the worker to `work_in_right` and decrement the number of boxes.
+
+Repeat the above process until the number of boxes is zero. At this point, `cur` is the answer.
+
+The time complexity is $O(n \times \log k)$, and the space complexity is $O(k)$. Here, $n$ and $k$ are the number of workers and the number of boxes, respectively.
 
 <!-- tabs:start -->
 

solution/2500-2599/2534.Time Taken to Cross the Door/README.md

@@ -90,25 +90,159 @@ tags:
 #### Python3
 
 ```python
-
+class Solution:
+    def timeTaken(self, arrival: List[int], state: List[int]) -> List[int]:
+        q = [deque(), deque()]
+        n = len(arrival)
+        t = i = 0
+        st = 1
+        ans = [0] * n
+        while i < n or q[0] or q[1]:
+            while i < n and arrival[i] <= t:
+                q[state[i]].append(i)
+                i += 1
+            if q[0] and q[1]:
+                ans[q[st].popleft()] = t
+            elif q[0] or q[1]:
+                st = 0 if q[0] else 1
+                ans[q[st].popleft()] = t
+            else:
+                st = 1
+            t += 1
+        return ans
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public int[] timeTaken(int[] arrival, int[] state) {
+        Deque<Integer>[] q = new Deque[2];
+        Arrays.setAll(q, i -> new ArrayDeque<>());
+        int n = arrival.length;
+        int t = 0, i = 0, st = 1;
+        int[] ans = new int[n];
+        while (i < n || !q[0].isEmpty() || !q[1].isEmpty()) {
+            while (i < n && arrival[i] <= t) {
+                q[state[i]].add(i++);
+            }
+            if (!q[0].isEmpty() && !q[1].isEmpty()) {
+                ans[q[st].poll()] = t;
+            } else if (!q[0].isEmpty() || !q[1].isEmpty()) {
+                st = q[0].isEmpty() ? 1 : 0;
+                ans[q[st].poll()] = t;
+            } else {
+                st = 1;
+            }
+            ++t;
+        }
+        return ans;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    vector<int> timeTaken(vector<int>& arrival, vector<int>& state) {
+        int n = arrival.size();
+        queue<int> q[2];
+        int t = 0, i = 0, st = 1;
+        vector<int> ans(n);
+
+        while (i < n || !q[0].empty() || !q[1].empty()) {
+            while (i < n && arrival[i] <= t) {
+                q[state[i]].push(i++);
+            }
+
+            if (!q[0].empty() && !q[1].empty()) {
+                ans[q[st].front()] = t;
+                q[st].pop();
+            } else if (!q[0].empty() || !q[1].empty()) {
+                st = q[0].empty() ? 1 : 0;
+                ans[q[st].front()] = t;
+                q[st].pop();
+            } else {
+                st = 1;
+            }
+
+            ++t;
+        }
+
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func timeTaken(arrival []int, state []int) []int {
+	n := len(arrival)
+	q := [2][]int{}
+	t, i, st := 0, 0, 1
+	ans := make([]int, n)
+
+	for i < n || len(q[0]) > 0 || len(q[1]) > 0 {
+		for i < n && arrival[i] <= t {
+			q[state[i]] = append(q[state[i]], i)
+			i++
+		}
+
+		if len(q[0]) > 0 && len(q[1]) > 0 {
+			ans[q[st][0]] = t
+			q[st] = q[st][1:]
+		} else if len(q[0]) > 0 || len(q[1]) > 0 {
+			if len(q[0]) == 0 {
+				st = 1
+			} else {
+				st = 0
+			}
+			ans[q[st][0]] = t
+			q[st] = q[st][1:]
+		} else {
+			st = 1
+		}
+
+		t++
+	}
+
+	return ans
+}
+```
 
+#### TypeScript
+
+```ts
+function timeTaken(arrival: number[], state: number[]): number[] {
+    const n = arrival.length;
+    const q: number[][] = [[], []];
+    let [t, i, st] = [0, 0, 1];
+    const ans: number[] = Array(n).fill(0);
+
+    while (i < n || q[0].length || q[1].length) {
+        while (i < n && arrival[i] <= t) {
+            q[state[i]].push(i++);
+        }
+
+        if (q[0].length && q[1].length) {
+            ans[q[st][0]] = t;
+            q[st].shift();
+        } else if (q[0].length || q[1].length) {
+            st = q[0].length ? 0 : 1;
+            ans[q[st][0]] = t;
+            q[st].shift();
+        } else {
+            st = 1;
+        }
+
+        t++;
+    }
+
+    return ans;
+}
 ```
 
 <!-- tabs:end -->

solution/2500-2599/2534.Time Taken to Cross the Door/README_EN.md

@@ -89,25 +89,159 @@ tags:
 #### Python3
 
 ```python
-
+class Solution:
+    def timeTaken(self, arrival: List[int], state: List[int]) -> List[int]:
+        q = [deque(), deque()]
+        n = len(arrival)
+        t = i = 0
+        st = 1
+        ans = [0] * n
+        while i < n or q[0] or q[1]:
+            while i < n and arrival[i] <= t:
+                q[state[i]].append(i)
+                i += 1
+            if q[0] and q[1]:
+                ans[q[st].popleft()] = t
+            elif q[0] or q[1]:
+                st = 0 if q[0] else 1
+                ans[q[st].popleft()] = t
+            else:
+                st = 1
+            t += 1
+        return ans
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public int[] timeTaken(int[] arrival, int[] state) {
+        Deque<Integer>[] q = new Deque[2];
+        Arrays.setAll(q, i -> new ArrayDeque<>());
+        int n = arrival.length;
+        int t = 0, i = 0, st = 1;
+        int[] ans = new int[n];
+        while (i < n || !q[0].isEmpty() || !q[1].isEmpty()) {
+            while (i < n && arrival[i] <= t) {
+                q[state[i]].add(i++);
+            }
+            if (!q[0].isEmpty() && !q[1].isEmpty()) {
+                ans[q[st].poll()] = t;
+            } else if (!q[0].isEmpty() || !q[1].isEmpty()) {
+                st = q[0].isEmpty() ? 1 : 0;
+                ans[q[st].poll()] = t;
+            } else {
+                st = 1;
+            }
+            ++t;
+        }
+        return ans;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    vector<int> timeTaken(vector<int>& arrival, vector<int>& state) {
+        int n = arrival.size();
+        queue<int> q[2];
+        int t = 0, i = 0, st = 1;
+        vector<int> ans(n);
+
+        while (i < n || !q[0].empty() || !q[1].empty()) {
+            while (i < n && arrival[i] <= t) {
+                q[state[i]].push(i++);
+            }
+
+            if (!q[0].empty() && !q[1].empty()) {
+                ans[q[st].front()] = t;
+                q[st].pop();
+            } else if (!q[0].empty() || !q[1].empty()) {
+                st = q[0].empty() ? 1 : 0;
+                ans[q[st].front()] = t;
+                q[st].pop();
+            } else {
+                st = 1;
+            }
+
+            ++t;
+        }
+
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func timeTaken(arrival []int, state []int) []int {
+	n := len(arrival)
+	q := [2][]int{}
+	t, i, st := 0, 0, 1
+	ans := make([]int, n)
+
+	for i < n || len(q[0]) > 0 || len(q[1]) > 0 {
+		for i < n && arrival[i] <= t {
+			q[state[i]] = append(q[state[i]], i)
+			i++
+		}
+
+		if len(q[0]) > 0 && len(q[1]) > 0 {
+			ans[q[st][0]] = t
+			q[st] = q[st][1:]
+		} else if len(q[0]) > 0 || len(q[1]) > 0 {
+			if len(q[0]) == 0 {
+				st = 1
+			} else {
+				st = 0
+			}
+			ans[q[st][0]] = t
+			q[st] = q[st][1:]
+		} else {
+			st = 1
+		}
+
+		t++
+	}
+
+	return ans
+}
+```
 
+#### TypeScript
+
+```ts
+function timeTaken(arrival: number[], state: number[]): number[] {
+    const n = arrival.length;
+    const q: number[][] = [[], []];
+    let [t, i, st] = [0, 0, 1];
+    const ans: number[] = Array(n).fill(0);
+
+    while (i < n || q[0].length || q[1].length) {
+        while (i < n && arrival[i] <= t) {
+            q[state[i]].push(i++);
+        }
+
+        if (q[0].length && q[1].length) {
+            ans[q[st][0]] = t;
+            q[st].shift();
+        } else if (q[0].length || q[1].length) {
+            st = q[0].length ? 0 : 1;
+            ans[q[st][0]] = t;
+            q[st].shift();
+        } else {
+            st = 1;
+        }
+
+        t++;
+    }
+
+    return ans;
+}
 ```
 
 <!-- tabs:end -->

solution/2500-2599/2534.Time Taken to Cross the Door/Solution.cpp

@@ -0,0 +1,30 @@
+class Solution {
+public:
+    vector<int> timeTaken(vector<int>& arrival, vector<int>& state) {
+        int n = arrival.size();
+        queue<int> q[2];
+        int t = 0, i = 0, st = 1;
+        vector<int> ans(n);
+
+        while (i < n || !q[0].empty() || !q[1].empty()) {
+            while (i < n && arrival[i] <= t) {
+                q[state[i]].push(i++);
+            }
+
+            if (!q[0].empty() && !q[1].empty()) {
+                ans[q[st].front()] = t;
+                q[st].pop();
+            } else if (!q[0].empty() || !q[1].empty()) {
+                st = q[0].empty() ? 1 : 0;
+                ans[q[st].front()] = t;
+                q[st].pop();
+            } else {
+                st = 1;
+            }
+
+            ++t;
+        }
+
+        return ans;
+    }
+};