add solutions, explanation and update the README file of the day 1462

Author: Aarzoo

Algorithms/README.md

@@ -42,7 +42,8 @@
 | 1400            | Construct K Palindrome Strings  | [C++](./Algorithms/src/1400.%20Construct%20K%20Palindrome%20Strings/Code/solution.cpp), [Java](./Algorithms/src/1400.%20Construct%20K%20Palindrome%20Strings/Code/solution.java), [JavaScript](./Algorithms/src/1400.%20Construct%20K%20Palindrome%20Strings/Code/solution.js), [Python](./Algorithms/src/1400.%20Construct%20K%20Palindrome%20Strings/Code/solution.py), [Go](./Algorithms/src/1400.%20Construct%20K%20Palindrome%20Strings/Code/solution.go) | [Explanation](./Algorithms/src/1400.%20Construct%20K%20Palindrome%20Strings/Explanation/explanation.md)   | Medium             |
 | 1405            | Longest Happy String  | [C++](./Algorithms/src/1405.%20Longest%20Happy%20String/Code/solution.cpp), [Java](./Algorithms/src/1405.%20Longest%20Happy%20String/Code/solution.java), [JavaScript](./Algorithms/src/1405.%20Longest%20Happy%20String/Code/solution.js), [Python](./Algorithms/src/1405.%20Longest%20Happy%20String/Code/solution.py), [Go](./Algorithms/src/1405.%20Longest%20Happy%20String/Code/solution.go) | [Explanation](./Algorithms/src/1405.%20Longest%20Happy%20String/Explanation/explanation.md)   | Medium             |
 | 1408            | String Matching in an Array  | [C++](./Algorithms/src/1408.%20String%20Matching%20in%20an%20Array/Code/solution.cpp), [Java](./Algorithms/src/1408.%20String%20Matching%20in%20an%20Array/Code/solution.java), [JavaScript](./Algorithms/src/1408.%20String%20Matching%20in%20an%20Array/Code/solution.js), [Python](./Algorithms/src/1408.%20String%20Matching%20in%20an%20Array/Code/solution.py), [Go](./Algorithms/src/1408.%20String%20Matching%20in%20an%20Array/Code/solution.go) | [Explanation](./Algorithms/src/1408.%20String%20Matching%20in%20an%20Array/Explanation/explanation.md)   | Easy             |
-| 1460            | Make Two Arrays Equal by Reversing Subarrays  | [C++](./Algorithms/src/1460.%20Make%20Two%20Arrays%20Equal%20by%20Reversing%20Subarrays/Code/solution.cpp), [Java](./Algorithms/src/1460.%20Make%20Two%20Arrays%20Equal%20by%20Reversing%20Subarrays/Code/solution.java), [JavaScript](./Algorithms/src/1460.%20Make%20Two%20Arrays%20Equal%20by%20Reversing%20Subarrays/Code/solution.js), [Python](./Algorithms/src/1460.%20Make%20Two%20Arrays%20Equal%20by%20Reversing%20Subarrays/Code/solution.py), [Go](./Algorithms/src/1598.1460.%20Make%20Two%20Arrays%20Equal%20by%20Reversing%20Subarrays/solution.go) | [Explanation](./Algorithms/src/1460.%20Make%20Two%20Arrays%20Equal%20by%20Reversing%20Subarrays/Explanation/explanation.md)   | Easy             |
+| 1460            | Make Two Arrays Equal by Reversing Subarrays  | [C++](./Algorithms/src/1460.%20Make%20Two%20Arrays%20Equal%20by%20Reversing%20Subarrays/Code/solution.cpp), [Java](./Algorithms/src/1460.%20Make%20Two%20Arrays%20Equal%20by%20Reversing%20Subarrays/Code/solution.java), [JavaScript](./Algorithms/src/1460.%20Make%20Two%20Arrays%20Equal%20by%20Reversing%20Subarrays/Code/solution.js), [Python](./Algorithms/src/1460.%20Make%20Two%20Arrays%20Equal%20by%20Reversing%20Subarrays/Code/solution.py), [Go](./Algorithms/src/1598.1460.%20Make%20Two%20Arrays%20Equal%20by%20Reversing%20Subarrays/Code/solution.go) | [Explanation](./Algorithms/src/1460.%20Make%20Two%20Arrays%20Equal%20by%20Reversing%20Subarrays/Explanation/explanation.md)   | Easy             |
+| 1462            | Course Schedule IV  | [C++](./Algorithms/src/1462.%20Course%20Schedule%20IV/Code/solution.cpp), [Java](./Algorithms/src/1462.%20Course%20Schedule%20IV/Code/solution.java), [JavaScript](./Algorithms/src/1462.%20Course%20Schedule%20IV/Code/solution.js), [Python](./Algorithms/src/1462.%20Course%20Schedule%20IV/Code/solution.py), [Go](./Algorithms/src/1598.1462.%20Course%20Schedule%20IV/Code/solution.go) | [Explanation](./Algorithms/src/1462.%20Course%20Schedule%20IV/Explanation/explanation.md)   | Medium             |
 | 1497            | Check If Array Pairs Are Divisible by k  | [C++](./Algorithms/src/1497.%20Check%20If%20Array%20Pairs%20Are%20Divisible%20by%20k/Code/solution.cpp), [Java](./Algorithms/src/1497.%20Check%20If%20Array%20Pairs%20Are%20Divisible%20by%20k/Code/solution.java), [JavaScript](./Algorithms/src/1497.%20Check%20If%20Array%20Pairs%20Are%20Divisible%20by%20k/Code/solution.js), [Python](./Algorithms/src/1497.%20Check%20If%20Array%20Pairs%20Are%20Divisible%20by%20k/Code/solution.py), [Go](./Algorithms/src/1598.1497.%20Check%20If%20Array%20Pairs%20Are%20Divisible%20by%20k/solution.go) | [Explanation](./Algorithms/src/1497.%20Check%20If%20Array%20Pairs%20Are%20Divisible%20by%20k/Explanation/explanation.md)   | Medium             |
 | 1509            | Minimum Difference Between Largest and Smallest Value in Three Moves  | [C++](./Algorithms/src/1509.%20Minimum%20Difference%20Between%20Largest%20and%20Smallest%20Value%20in%20Three%20Moves/Code/solution.cpp), [Java](./Algorithms/src/1509.%20Minimum%20Difference%20Between%20Largest%20and%20Smallest%20Value%20in%20Three%20Moves/Code/solution.java), [JavaScript](./Algorithms/src/1509.%20Minimum%20Difference%20Between%20Largest%20and%20Smallest%20Value%20in%20Three%20Moves/Code/solution.js), [Python](./Algorithms/src/1509.%20Minimum%20Difference%20Between%20Largest%20and%20Smallest%20Value%20in%20Three%20Moves/Code/solution.py), [Go](./Algorithms/src/1509.%20Minimum%20Difference%20Between%20Largest%20and%20Smallest%20Value%20in%20Three%20Moves/Code/solution.go) | [Explanation](./Algorithms/src/1509.%20Minimum%20Difference%20Between%20Largest%20and%20Smallest%20Value%20in%20Three%20Moves/Explanation/explanation.md)   | Medium             |
 | 1545            | Find Kth Bit in Nth Binary String  | [C++](./Algorithms/src/1545.%20Find%20Kth%20Bit%20in%20Nth%20Binary%20String/Code/solution.cpp), [Java](./Algorithms/src/1545.%20Find%20Kth%20Bit%20in%20Nth%20Binary%20String/Code/solution.java), [JavaScript](./Algorithms/src/1545.%20Find%20Kth%20Bit%20in%20Nth%20Binary%20String/Code/solution.js), [Python](./Algorithms/src/1545.%20Find%20Kth%20Bit%20in%20Nth%20Binary%20String/Code/solution.py), [Go](./Algorithms/src/1545.%20Find%20Kth%20Bit%20in%20Nth%20Binary%20String/Code/solution.go) | [Explanation](./Algorithms/src/1545.%20Find%20Kth%20Bit%20in%20Nth%20Binary%20String/Explanation/explanation.md)   | Medium             |

Algorithms/src/1462. Course Schedule IV/Code/solution.cpp

@@ -0,0 +1,39 @@
+class Solution
+{
+public:
+    vector<bool> checkIfPrerequisite(int numCourses, vector<vector<int>> &prerequisites, vector<vector<int>> &queries)
+    {
+        // Initialize the graph
+        vector<vector<bool>> graph(numCourses, vector<bool>(numCourses, false));
+
+        // Build the direct edges from prerequisites
+        for (const auto &edge : prerequisites)
+        {
+            graph[edge[0]][edge[1]] = true;
+        }
+
+        // Floyd-Warshall to compute transitive closure
+        for (int k = 0; k < numCourses; ++k)
+        {
+            for (int i = 0; i < numCourses; ++i)
+            {
+                for (int j = 0; j < numCourses; ++j)
+                {
+                    if (graph[i][k] && graph[k][j])
+                    {
+                        graph[i][j] = true;
+                    }
+                }
+            }
+        }
+
+        // Answer the queries
+        vector<bool> result;
+        for (const auto &query : queries)
+        {
+            result.push_back(graph[query[0]][query[1]]);
+        }
+
+        return result;
+    }
+};

Algorithms/src/1462. Course Schedule IV/Code/solution.go

@@ -0,0 +1,31 @@
+func checkIfPrerequisite(numCourses int, prerequisites [][]int, queries [][]int) []bool {
+    // Initialize the graph
+    graph := make([][]bool, numCourses)
+    for i := 0; i < numCourses; i++ {
+        graph[i] = make([]bool, numCourses)
+    }
+
+    // Build the direct edges from prerequisites
+    for _, edge := range prerequisites {
+        graph[edge[0]][edge[1]] = true
+    }
+
+    // Floyd-Warshall to compute transitive closure
+    for k := 0; k < numCourses; k++ {
+        for i := 0; i < numCourses; i++ {
+            for j := 0; j < numCourses; j++ {
+                if graph[i][k] && graph[k][j] {
+                    graph[i][j] = true
+                }
+            }
+        }
+    }
+
+    // Answer the queries
+    result := make([]bool, len(queries))
+    for i, query := range queries {
+        result[i] = graph[query[0]][query[1]]
+    }
+
+    return result
+}

Algorithms/src/1462. Course Schedule IV/Code/solution.java

@@ -0,0 +1,30 @@
+class Solution {
+    public List<Boolean> checkIfPrerequisite(int numCourses, int[][] prerequisites, int[][] queries) {
+        // Initialize the graph
+        boolean[][] graph = new boolean[numCourses][numCourses];
+
+        // Build the direct edges from prerequisites
+        for (int[] edge : prerequisites) {
+            graph[edge[0]][edge[1]] = true;
+        }
+
+        // Floyd-Warshall to compute transitive closure
+        for (int k = 0; k < numCourses; k++) {
+            for (int i = 0; i < numCourses; i++) {
+                for (int j = 0; j < numCourses; j++) {
+                    if (graph[i][k] && graph[k][j]) {
+                        graph[i][j] = true;
+                    }
+                }
+            }
+        }
+
+        // Answer the queries
+        List<Boolean> result = new ArrayList<>();
+        for (int[] query : queries) {
+            result.add(graph[query[0]][query[1]]);
+        }
+
+        return result;
+    }
+}

Algorithms/src/1462. Course Schedule IV/Code/solution.js

@@ -0,0 +1,25 @@
+var checkIfPrerequisite = function (numCourses, prerequisites, queries) {
+  // Initialize the graph
+  const graph = Array.from({ length: numCourses }, () =>
+    Array(numCourses).fill(false)
+  );
+
+  // Build the direct edges from prerequisites
+  for (const [u, v] of prerequisites) {
+    graph[u][v] = true;
+  }
+
+  // Floyd-Warshall to compute transitive closure
+  for (let k = 0; k < numCourses; k++) {
+    for (let i = 0; i < numCourses; i++) {
+      for (let j = 0; j < numCourses; j++) {
+        if (graph[i][k] && graph[k][j]) {
+          graph[i][j] = true;
+        }
+      }
+    }
+  }
+
+  // Answer the queries
+  return queries.map(([u, v]) => graph[u][v]);
+};

Algorithms/src/1462. Course Schedule IV/Code/solution.py

@@ -0,0 +1,18 @@
+class Solution:
+    def checkIfPrerequisite(self, numCourses: int, prerequisites: List[List[int]], queries: List[List[int]]) -> List[bool]:
+        # Initialize the graph
+        graph = [[False] * numCourses for _ in range(numCourses)]
+
+        # Build the direct edges from prerequisites
+        for u, v in prerequisites:
+            graph[u][v] = True
+
+        # Floyd-Warshall to compute transitive closure
+        for k in range(numCourses):
+            for i in range(numCourses):
+                for j in range(numCourses):
+                    if graph[i][k] and graph[k][j]:
+                        graph[i][j] = True
+
+        # Answer the queries
+        return [graph[u][v] for u, v in queries]

Algorithms/src/1462. Course Schedule IV/Explanation/explanation.md

@@ -0,0 +1,109 @@
+# Problem: Check If a Prerequisite Exists
+
+This repository provides solutions to the problem "Check If a Prerequisite Exists" implemented in **C++**, **Java**, **JavaScript**, **Python**, and **Go**. Below, you'll find step-by-step explanations for each language.
+
+---
+
+## C++ Code Implementation: Step-by-Step
+
+1. **Initialize the Adjacency Matrix**  
+   Start by initializing a 2D matrix to store whether a course is a prerequisite of another course.
+
+2. **Set up the Prerequisite Relationships**  
+   Using the prerequisites list, update the adjacency matrix with direct relationships between courses.
+
+3. **Floyd-Warshall Algorithm**  
+   Apply the Floyd-Warshall algorithm to compute all pairs' reachability. This updates the matrix to reflect indirect prerequisites.
+
+4. **Process the Queries**  
+   For each query, check the adjacency matrix to see if one course is a prerequisite of another.
+
+---
+
+## Java Code Implementation: Step-by-Step
+
+1. **Prepare the Adjacency Matrix**  
+   Create a 2D array to store whether a course is a prerequisite for another.
+
+2. **Update Relationships from Prerequisites**  
+   Populate the matrix with the prerequisites directly given in the input.
+
+3. **Use Floyd-Warshall Algorithm**  
+   Implement Floyd-Warshall to ensure all transitive prerequisites are captured in the matrix.
+
+4. **Answer the Queries**  
+   For each query, use the matrix to determine if the prerequisite relationship exists.
+
+---
+
+## JavaScript Code Implementation: Step-by-Step
+
+1. **Build the Graph**  
+   Create a graph representation using a 2D array to represent the prerequisite relationships.
+
+2. **Populate Direct Relationships**  
+   Populate the graph with direct prerequisites using the input data.
+
+3. **Compute Transitive Closure**  
+   Utilize the Floyd-Warshall algorithm to compute transitive relationships between courses.
+
+4. **Evaluate Queries**  
+   Loop through each query and return whether the course relationship exists.
+
+---
+
+## Python Code Implementation: Step-by-Step
+
+1. **Initialize a 2D Matrix**  
+   Create a matrix where `matrix[i][j]` indicates whether course `i` is a prerequisite for course `j`.
+
+2. **Update the Matrix for Direct Prerequisites**  
+   Populate the matrix with the relationships provided in the prerequisites list.
+
+3. **Apply Floyd-Warshall Algorithm**  
+   Implement the Floyd-Warshall algorithm to find all indirect relationships between courses.
+
+4. **Answer the Queries**  
+   For each query, check the value in the matrix to determine if the prerequisite exists.
+
+---
+
+## Go Code Implementation: Step-by-Step
+
+1. **Set up the Graph as a 2D Slice**  
+   Initialize a 2D slice to represent the adjacency matrix of course relationships.
+
+2. **Add Direct Relationships**  
+   Update the graph with the direct prerequisites based on the input data.
+
+3. **Floyd-Warshall Algorithm for Transitive Closure**  
+   Implement Floyd-Warshall to propagate indirect prerequisites across the matrix.
+
+4. **Handle Queries**  
+   For each query, determine whether a course is a prerequisite by checking the matrix.
+
+---
+
+Each implementation shares a common approach:
+
+1. Build a representation of prerequisites.  
+2. Compute all transitive relationships using the Floyd-Warshall algorithm.  
+3. Check the matrix to answer queries.
+
+For the complete implementation, refer to the respective files:  
+
+- `solution.cpp`  
+- `solution.java`  
+- `solution.js`  
+- `solution.py`  
+- `solution.go`
+
+---
+
+### Complexity Analysis
+
+- **Time Complexity**:  
+  The Floyd-Warshall algorithm takes $$O(n^3)$$ time, where \(n\) is the number of courses. Processing the queries takes $$O(q)$$, where \(q\) is the number of queries.  
+
+- **Space Complexity**:  
+  The space complexity is $$O(n^2)$$ for the adjacency matrix.