feat: add 1361,2050

Author: BaffinLee

1301-1400/1361. Validate Binary Tree Nodes.md

@@ -0,0 +1,90 @@
+# 1361. Validate Binary Tree Nodes
+
+- Difficulty: Medium.
+- Related Topics: Tree, Depth-First Search, Breadth-First Search, Union Find, Graph, Binary Tree.
+- Similar Questions: .
+
+## Problem
+
+You have `n` binary tree nodes numbered from `0` to `n - 1` where node `i` has two children `leftChild[i]` and `rightChild[i]`, return `true` if and only if **all** the given nodes form **exactly one** valid binary tree.
+
+If node `i` has no left child then `leftChild[i]` will equal `-1`, similarly for the right child.
+
+Note that the nodes have no values and that we only use the node numbers in this problem.
+
+ 
+Example 1:
+
+![](https://assets.leetcode.com/uploads/2019/08/23/1503_ex1.png)
+
+```
+Input: n = 4, leftChild = [1,-1,3,-1], rightChild = [2,-1,-1,-1]
+Output: true
+```
+
+Example 2:
+
+![](https://assets.leetcode.com/uploads/2019/08/23/1503_ex2.png)
+
+```
+Input: n = 4, leftChild = [1,-1,3,-1], rightChild = [2,3,-1,-1]
+Output: false
+```
+
+Example 3:
+
+![](https://assets.leetcode.com/uploads/2019/08/23/1503_ex3.png)
+
+```
+Input: n = 2, leftChild = [1,0], rightChild = [-1,-1]
+Output: false
+```
+
+ 
+**Constraints:**
+
+
+	
+- `n == leftChild.length == rightChild.length`
+	
+- `1 <= n <= 104`
+	
+- `-1 <= leftChild[i], rightChild[i] <= n - 1`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number} n
+ * @param {number[]} leftChild
+ * @param {number[]} rightChild
+ * @return {boolean}
+ */
+var validateBinaryTreeNodes = function(n, leftChild, rightChild) {
+    var indegree = Array(n).fill(0);
+    for (var i = 0; i < n; i++) {
+        leftChild[i] !== -1 && indegree[leftChild[i]]++;
+        rightChild[i] !== -1 && indegree[rightChild[i]]++;
+    }
+    var root = indegree.findIndex(num => num === 0);
+    var visited = Array(n).fill(false);
+    var visit = function(node) {
+        if (visited[node]) return false;
+        visited[node] = true;
+        return (leftChild[node] === -1 || visit(leftChild[node]))
+            && (rightChild[node] === -1 || visit(rightChild[node]));
+    };
+    return visit(root) && visited.every(n => n);
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).

2001-2100/2050. Parallel Courses III.md

@@ -0,0 +1,122 @@
+# 2050. Parallel Courses III
+
+- Difficulty: Hard.
+- Related Topics: Array, Dynamic Programming, Graph, Topological Sort.
+- Similar Questions: Course Schedule III, Parallel Courses, Single-Threaded CPU, Process Tasks Using Servers, Maximum Employees to Be Invited to a Meeting.
+
+## Problem
+
+You are given an integer `n`, which indicates that there are `n` courses labeled from `1` to `n`. You are also given a 2D integer array `relations` where `relations[j] = [prevCoursej, nextCoursej]` denotes that course `prevCoursej` has to be completed **before** course `nextCoursej` (prerequisite relationship). Furthermore, you are given a **0-indexed** integer array `time` where `time[i]` denotes how many **months** it takes to complete the `(i+1)th` course.
+
+You must find the **minimum** number of months needed to complete all the courses following these rules:
+
+
+	
+- You may start taking a course at **any time** if the prerequisites are met.
+	
+- **Any number of courses** can be taken at the **same time**.
+
+
+Return **the **minimum** number of months needed to complete all the courses**.
+
+**Note:** The test cases are generated such that it is possible to complete every course (i.e., the graph is a directed acyclic graph).
+
+ 
+Example 1:
+
+![](https://assets.leetcode.com/uploads/2021/10/07/ex1.png)
+
+
+```
+Input: n = 3, relations = [[1,3],[2,3]], time = [3,2,5]
+Output: 8
+Explanation: The figure above represents the given graph and the time required to complete each course. 
+We start course 1 and course 2 simultaneously at month 0.
+Course 1 takes 3 months and course 2 takes 2 months to complete respectively.
+Thus, the earliest time we can start course 3 is at month 3, and the total time required is 3 + 5 = 8 months.
+```
+
+Example 2:
+
+![](https://assets.leetcode.com/uploads/2021/10/07/ex2.png)
+
+
+```
+Input: n = 5, relations = [[1,5],[2,5],[3,5],[3,4],[4,5]], time = [1,2,3,4,5]
+Output: 12
+Explanation: The figure above represents the given graph and the time required to complete each course.
+You can start courses 1, 2, and 3 at month 0.
+You can complete them after 1, 2, and 3 months respectively.
+Course 4 can be taken only after course 3 is completed, i.e., after 3 months. It is completed after 3 + 4 = 7 months.
+Course 5 can be taken only after courses 1, 2, 3, and 4 have been completed, i.e., after max(1,2,3,7) = 7 months.
+Thus, the minimum time needed to complete all the courses is 7 + 5 = 12 months.
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= n <= 5 * 104`
+	
+- `0 <= relations.length <= min(n * (n - 1) / 2, 5 * 104)`
+	
+- `relations[j].length == 2`
+	
+- `1 <= prevCoursej, nextCoursej <= n`
+	
+- `prevCoursej != nextCoursej`
+	
+- All the pairs `[prevCoursej, nextCoursej]` are **unique**.
+	
+- `time.length == n`
+	
+- `1 <= time[i] <= 104`
+	
+- The given graph is a directed acyclic graph.
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number} n
+ * @param {number[][]} relations
+ * @param {number[]} time
+ * @return {number}
+ */
+var minimumTime = function(n, relations, time) {
+    var graph = Array(n).fill(0).map(() => []);
+    for (var i = 0; i < relations.length; i++) {
+        var [a, b] = relations[i];
+        graph[a - 1].push(b - 1);
+    }
+
+    var max = 0;
+    var dp = Array(n);
+    for (var i = 0; i < n; i++) {
+        max = Math.max(max, dfs(i, graph, time, dp));
+    }
+    return max;
+};
+
+var dfs = function(i, graph, time, dp) {
+    if (dp[i] !== undefined) return dp[i];
+    var max = 0;
+    for (var j = 0; j < graph[i].length; j++) {
+        max = Math.max(max, dfs(graph[i][j], graph, time, dp));
+    }
+    dp[i] = max + time[i];
+    return dp[i];
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n + m).
+* Space complexity : O(n + m).