feat: add solutions to lc problem: No.1462

No.1462.Course Schedule IV

Author: yanglbme

Diff for: solution/0400-0499/0444.Sequence Reconstruction/README_EN.md

@@ -4,55 +4,68 @@
 
 ## Description
 
-<p>Check whether the original sequence <code>org</code> can be uniquely reconstructed from the sequences in <code>seqs</code>. The <code>org</code> sequence is a permutation of the integers from 1 to n, with 1 &le; n &le; 10<sup>4</sup>. Reconstruction means building a shortest common supersequence of the sequences in <code>seqs</code> (i.e., a shortest sequence so that all sequences in <code>seqs</code> are subsequences of it). Determine whether there is only one sequence that can be reconstructed from <code>seqs</code> and it is the <code>org</code> sequence.</p>
+<p>You are given an integer array <code>nums</code> of length <code>n</code> where <code>nums</code> is a permutation of the integers in the range <code>[1, n]</code>. You are also given a 2D integer array <code>sequences</code> where <code>sequences[i]</code> is a subsequence of <code>nums</code>.</p>
+
+<p>Check if <code>nums</code> is the shortest possible and the only <strong>supersequence</strong>. The shortest <strong>supersequence</strong> is a sequence <strong>with the shortest length</strong> and has all <code>sequences[i]</code> as subsequences. There could be multiple valid <strong>supersequences</strong> for the given array <code>sequences</code>.</p>
+
+<ul>
+	<li>For example, for <code>sequences = [[1,2],[1,3]]</code>, there are two shortest <strong>supersequences</strong>, <code>[1,2,3]</code> and <code>[1,3,2]</code>.</li>
+	<li>While for <code>sequences = [[1,2],[1,3],[1,2,3]]</code>, the only shortest <strong>supersequence</strong> possible is <code>[1,2,3]</code>. <code>[1,2,3,4]</code> is a possible supersequence but not the shortest.</li>
+</ul>
+
+<p>Return <code>true</code><em> if </em><code>nums</code><em> is the only shortest <strong>supersequence</strong> for </em><code>sequences</code><em>, or </em><code>false</code><em> otherwise</em>.</p>
+
+<p>A <strong>subsequence</strong> is a sequence that can be derived from another sequence by deleting some or no elements without changing the order of the remaining elements.</p>
 
 <p>&nbsp;</p>
 <p><strong>Example 1:</strong></p>
 
 <pre>
-<strong>Input:</strong> org = [1,2,3], seqs = [[1,2],[1,3]]
+<strong>Input:</strong> nums = [1,2,3], sequences = [[1,2],[1,3]]
 <strong>Output:</strong> false
-<strong>Explanation:</strong> [1,2,3] is not the only one sequence that can be reconstructed, because [1,3,2] is also a valid sequence that can be reconstructed.
+<strong>Explanation:</strong> There are two possible supersequences: [1,2,3] and [1,3,2].
+The sequence [1,2] is a subsequence of both: [<strong><u>1</u></strong>,<strong><u>2</u></strong>,3] and [<strong><u>1</u></strong>,3,<strong><u>2</u></strong>].
+The sequence [1,3] is a subsequence of both: [<strong><u>1</u></strong>,2,<strong><u>3</u></strong>] and [<strong><u>1</u></strong>,<strong><u>3</u></strong>,2].
+Since nums is not the only shortest supersequence, we return false.
 </pre>
 
 <p><strong>Example 2:</strong></p>
 
 <pre>
-<strong>Input:</strong> org = [1,2,3], seqs = [[1,2]]
+<strong>Input:</strong> nums = [1,2,3], sequences = [[1,2]]
 <strong>Output:</strong> false
-<strong>Explanation:</strong> The reconstructed sequence can only be [1,2].
+<strong>Explanation:</strong> The shortest possible supersequence is [1,2].
+The sequence [1,2] is a subsequence of it: [<strong><u>1</u></strong>,<strong><u>2</u></strong>].
+Since nums is not the shortest supersequence, we return false.
 </pre>
 
 <p><strong>Example 3:</strong></p>
 
 <pre>
-<strong>Input:</strong> org = [1,2,3], seqs = [[1,2],[1,3],[2,3]]
-<strong>Output:</strong> true
-<strong>Explanation:</strong> The sequences [1,2], [1,3], and [2,3] can uniquely reconstruct the original sequence [1,2,3].
-</pre>
-
-<p><strong>Example 4:</strong></p>
-
-<pre>
-<strong>Input:</strong> org = [4,1,5,2,6,3], seqs = [[5,2,6,3],[4,1,5,2]]
+<strong>Input:</strong> nums = [1,2,3], sequences = [[1,2],[1,3],[2,3]]
 <strong>Output:</strong> true
+<strong>Explanation:</strong> The shortest possible supersequence is [1,2,3].
+The sequence [1,2] is a subsequence of it: [<strong><u>1</u></strong>,<strong><u>2</u></strong>,3].
+The sequence [1,3] is a subsequence of it: [<strong><u>1</u></strong>,2,<strong><u>3</u></strong>].
+The sequence [2,3] is a subsequence of it: [1,<strong><u>2</u></strong>,<strong><u>3</u></strong>].
+Since nums is the only shortest supersequence, we return true.
 </pre>
 
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>
 
 <ul>
-	<li><code>1 &lt;= n &lt;= 10^4</code></li>
-	<li><code>org</code> is a permutation of {1,2,...,n}.</li>
-	<li><code>1 &lt;= segs[i].length &lt;= 10^5</code></li>
-	<li><code>seqs[i][j]</code>&nbsp;fits in a 32-bit signed integer.</li>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>4</sup></code></li>
+	<li><code>nums</code> is a permutation of all the integers in the range <code>[1, n]</code>.</li>
+	<li><code>1 &lt;= sequences.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= sequences[i].length &lt;= 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= sum(sequences[i].length) &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= sequences[i][j] &lt;= n</code></li>
+	<li>All the arrays of <code>sequences</code> are <strong>unique</strong>.</li>
+	<li><code>sequences[i]</code> is a subsequence of <code>nums</code>.</li>
 </ul>
 
-<p>&nbsp;</p>
-
-<p><b><font color="red">UPDATE (2017/1/8):</font></b><br />
-The <i>seqs</i> parameter had been changed to a list of list of strings (instead of a 2d array of strings). Please reload the code definition to get the latest changes.</p>
-
 ## Solutions
 
 <!-- tabs:start -->

Diff for: solution/1400-1499/1462.Course Schedule IV/README.md

@@ -75,22 +75,157 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+DFS 记忆化搜索。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def checkIfPrerequisite(self, numCourses: int, prerequisites: List[List[int]], queries: List[List[int]]) -> List[bool]:
+        @lru_cache(None)
+        def dfs(a, b):
+            if b in g[a] or a == b:
+                return True
+            for c in g[a]:
+                if dfs(c, b):
+                    return True
+            return False
+
+        g = defaultdict(set)
+        for a, b in prerequisites:
+            g[a].add(b)
+        return [dfs(a, b) for a, b in queries]
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public List<Boolean> checkIfPrerequisite(int numCourses, int[][] prerequisites, int[][] queries) {
+        int[][] g = new int[numCourses][numCourses];
+        for (int i = 0; i < numCourses; ++i) {
+            Arrays.fill(g[i], -1);
+        }
+        for (int[] e : prerequisites) {
+            int a = e[0], b = e[1];
+            g[a][b] = 1;
+        }
+        List<Boolean> ans = new ArrayList<>();
+        for (int[] e : queries) {
+            int a = e[0], b = e[1];
+            ans.add(dfs(a, b, g));
+        }
+        return ans;
+    }
+
+    private boolean dfs(int a, int b, int[][] g) {
+        if (g[a][b] != -1) {
+            return g[a][b] == 1;
+        }
+        if (a == b) {
+            g[a][b] = 1;
+            return true;
+        }
+        for (int i = 0; i < g[a].length; ++i) {
+            if (g[a][i] == 1 && dfs(i, b, g)) {
+                g[a][b] = 1;
+                return true;
+            }
+        }
+        g[a][b] = 0;
+        return false;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<bool> checkIfPrerequisite(int numCourses, vector<vector<int>>& prerequisites, vector<vector<int>>& queries) {
+        vector<vector<int>> g(numCourses, vector<int>(numCourses, -1));
+        for (auto& e : prerequisites)
+        {
+            int a = e[0], b = e[1];
+            g[a][b] = 1;
+        }
+        vector<bool> ans;
+        for (auto& e : queries)
+        {
+            int a = e[0], b = e[1];
+            ans.push_back(dfs(a, b, g));
+        }
+        return ans;
+    }
+
+    bool dfs(int a, int b, vector<vector<int>>& g) {
+        if (g[a][b] != -1) return g[a][b] == 1;
+        if (a == b)
+        {
+            g[a][b] = 1;
+            return true;
+        }
+        for (int i = 0; i < g[a].size(); ++i)
+        {
+            if (g[a][i] == 1 && dfs(i, b, g))
+            {
+                g[a][b] = 1;
+                return true;
+            }
+        }
+        g[a][b] = 0;
+        return false;
+    }
+};
+```
 
+### **Go**
+
+```go
+func checkIfPrerequisite(numCourses int, prerequisites [][]int, queries [][]int) []bool {
+	g := make([][]int, numCourses)
+	for i := range g {
+		g[i] = make([]int, numCourses)
+		for j := range g[i] {
+			g[i][j] = -1
+		}
+	}
+	for _, e := range prerequisites {
+		a, b := e[0], e[1]
+		g[a][b] = 1
+	}
+	var ans []bool
+	var dfs func(a, b int) bool
+	dfs = func(a, b int) bool {
+		if g[a][b] != -1 {
+			return g[a][b] == 1
+		}
+		if a == b {
+			g[a][b] = 1
+			return true
+		}
+		for i, c := range g[a] {
+			if c == 1 && dfs(i, b) {
+				g[a][b] = 1
+				return true
+			}
+		}
+		g[a][b] = 0
+		return false
+	}
+	for _, e := range queries {
+		a, b := e[0], e[1]
+		ans = append(ans, dfs(a, b))
+	}
+	return ans
+}
 ```
 
 ### **...**