Add solution and explanation for problem 3764: Most Common Course Pairs

Author: vikahaze

data/leetcode-problems.json

@@ -26339,5 +26339,12 @@
     "title": "Maximum Substrings With Distinct Start",
     "difficulty": "Medium",
     "link": "https://leetcode.com/problems/maximum-substrings-with-distinct-start/"
+  },
+  "3764": {
+    "id": 3764,
+    "category": "Database",
+    "title": "Most Common Course Pairs",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/most-common-course-pairs/"
   }
 }

explanations/3764/en.md

@@ -0,0 +1,120 @@
+## Explanation
+
+### Strategy
+
+**Restate the problem**
+
+We need to analyze course completion data to find the most common learning pathways among top-performing students. A "pathway" is a sequence of two consecutive courses that a student completed. We only consider students who completed at least 5 courses with an average rating of 4 or higher.
+
+**1.1 Constraints & Complexity**
+
+- **Input Size:** The `course_completions` table can have N rows, where each row represents one course completion by a user.
+- **Time Complexity:** O(N log N) - We need to:
+  - Filter top performers: O(N) for grouping and aggregation
+  - Order courses chronologically: O(N log N) for window function sorting
+  - Join to create pairs: O(N) for the self-join
+  - Group and count pairs: O(N) for aggregation
+  - Final sorting: O(P log P) where P is the number of unique pairs (typically much smaller than N)
+  - Overall: O(N log N) dominated by the sorting step
+- **Space Complexity:** O(N) - We store intermediate results in CTEs (top performers list, ordered courses, and course pairs)
+- **Edge Case:** If no students meet the top performer criteria (at least 5 courses with average rating >= 4), the result will be an empty table.
+
+**1.2 High-level approach**
+
+The goal is to identify which course transitions are most popular among high-achieving students. We break this into three main steps: first, filter to only top performers; second, order each student's courses by completion date; third, extract consecutive pairs and count their frequencies.
+
+![Course pathway visualization showing students progressing through courses with arrows indicating transitions]
+
+**1.3 Brute force vs. optimized strategy**
+
+- **Brute Force:** For each student, check if they qualify as a top performer. Then, for each qualifying student, manually extract all consecutive course pairs by comparing every course with every other course. This would require nested loops and result in O(N²) time complexity.
+- **Optimized Strategy:** Use SQL window functions (ROW_NUMBER) to efficiently order courses chronologically, then use a self-join to create consecutive pairs in a single pass. This leverages SQL's optimized join and aggregation operations, resulting in O(N log N) time complexity.
+- **Emphasize the optimization:** By using window functions and structured CTEs, we let the database engine handle sorting and joining efficiently, avoiding manual iteration and reducing both code complexity and execution time.
+
+**1.4 Decomposition**
+
+1. **Identify Top Performers:** Group students by user_id, count their courses, and calculate average rating. Filter to only those with at least 5 courses and average rating >= 4.
+2. **Order Courses Chronologically:** For each top performer, assign a sequential number to their courses based on completion_date using a window function.
+3. **Create Consecutive Pairs:** Join the ordered courses table with itself, matching each course to the next course in sequence (where the order number differs by exactly 1).
+4. **Count Pair Frequencies:** Group the pairs by first_course and second_course, counting how many times each transition occurs.
+5. **Sort Results:** Order by transition_count descending, then by course names ascending.
+
+### Steps
+
+**2.1 Initialization & Example Setup**
+
+Let's use the example data from the problem:
+
+```
+User 1: Python Basics → SQL Fundamentals → JavaScript → React Basics → Node.js → Docker
+User 2: Python Basics → React Basics → Node.js → Docker → AWS Fundamentals
+User 3: Python Basics → SQL Fundamentals → JavaScript → React Basics → Node.js (doesn't qualify - avg rating 2.8)
+User 4: Python Basics → Data Science → Machine Learning (doesn't qualify - only 3 courses)
+```
+
+After filtering to top performers (Users 1 and 2), we have:
+- **Top Performers Set:** {User 1, User 2}
+- **User 1's ordered courses:** 
+  - Order 1: Python Basics
+  - Order 2: SQL Fundamentals
+  - Order 3: JavaScript
+  - Order 4: React Basics
+  - Order 5: Node.js
+  - Order 6: Docker
+- **User 2's ordered courses:**
+  - Order 1: Python Basics
+  - Order 2: React Basics
+  - Order 3: Node.js
+  - Order 4: Docker
+  - Order 5: AWS Fundamentals
+
+**2.2 Start Checking/Processing**
+
+We create consecutive pairs by joining each course with the next course in sequence. For User 1, we create pairs where course_order of the second course equals course_order + 1 of the first course.
+
+**2.3 Trace Walkthrough**
+
+Let's trace how pairs are created:
+
+| User | First Course | Second Course | Pair Created |
+|------|--------------|---------------|--------------|
+| 1 | Python Basics (order 1) | SQL Fundamentals (order 2) | Python Basics → SQL Fundamentals |
+| 1 | SQL Fundamentals (order 2) | JavaScript (order 3) | SQL Fundamentals → JavaScript |
+| 1 | JavaScript (order 3) | React Basics (order 4) | JavaScript → React Basics |
+| 1 | React Basics (order 4) | Node.js (order 5) | React Basics → Node.js |
+| 1 | Node.js (order 5) | Docker (order 6) | Node.js → Docker |
+| 2 | Python Basics (order 1) | React Basics (order 2) | Python Basics → React Basics |
+| 2 | React Basics (order 2) | Node.js (order 3) | React Basics → Node.js |
+| 2 | Node.js (order 3) | Docker (order 4) | Node.js → Docker |
+| 2 | Docker (order 4) | AWS Fundamentals (order 5) | Docker → AWS Fundamentals |
+
+**2.4 Count and Aggregate**
+
+After creating all pairs, we count their frequencies:
+
+| First Course | Second Course | Count |
+|--------------|---------------|-------|
+| Node.js | Docker | 2 |
+| React Basics | Node.js | 2 |
+| Docker | AWS Fundamentals | 1 |
+| JavaScript | React Basics | 1 |
+| Python Basics | React Basics | 1 |
+| Python Basics | SQL Fundamentals | 1 |
+| SQL Fundamentals | JavaScript | 1 |
+
+**2.5 Return Result**
+
+The final result is ordered by `transition_count` descending, then by `first_course` ascending, then by `second_course` ascending:
+
+| first_course | second_course | transition_count |
+|--------------|---------------|------------------|
+| Node.js | Docker | 2 |
+| React Basics | Node.js | 2 |
+| Docker | AWS Fundamentals | 1 |
+| JavaScript | React Basics | 1 |
+| Python Basics | React Basics | 1 |
+| Python Basics | SQL Fundamentals | 1 |
+| SQL Fundamentals | JavaScript | 1 |
+
+> **Note:** The window function `ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY completion_date)` ensures that courses are numbered sequentially for each student based on when they completed them, which is crucial for identifying consecutive pairs correctly.
+

solutions/3764/01.sql

@@ -0,0 +1,58 @@
+-- Solution for LeetCode 3764: Most Common Course Pairs
+-- Find skill mastery pathways by analyzing course completion sequences among top-performing students
+
+WITH top_performers AS (
+    -- Step 1: Identify top-performing students
+    -- Must have at least 5 courses with average rating >= 4
+    SELECT 
+        user_id
+    FROM 
+        course_completions
+    GROUP BY 
+        user_id
+    HAVING 
+        COUNT(*) >= 5 
+        AND AVG(course_rating) >= 4
+),
+ordered_courses AS (
+    -- Step 2: Get courses for top performers in chronological order
+    SELECT 
+        cc.user_id,
+        cc.course_name,
+        cc.completion_date,
+        ROW_NUMBER() OVER (
+            PARTITION BY cc.user_id 
+            ORDER BY cc.completion_date
+        ) AS course_order
+    FROM 
+        course_completions cc
+    INNER JOIN 
+        top_performers tp ON cc.user_id = tp.user_id
+),
+course_pairs AS (
+    -- Step 3: Create consecutive course pairs
+    SELECT 
+        oc1.course_name AS first_course,
+        oc2.course_name AS second_course
+    FROM 
+        ordered_courses oc1
+    INNER JOIN 
+        ordered_courses oc2 
+        ON oc1.user_id = oc2.user_id 
+        AND oc2.course_order = oc1.course_order + 1
+)
+-- Step 4: Count pair frequencies and order results
+SELECT 
+    first_course,
+    second_course,
+    COUNT(*) AS transition_count
+FROM 
+    course_pairs
+GROUP BY 
+    first_course, 
+    second_course
+ORDER BY 
+    transition_count DESC,
+    first_course ASC,
+    second_course ASC;
+