Merge pull request #124 from romankurnovskii/problems-2092-3716-3693

Add solutions and explanations for problems 2092, 3693, 3716

Author: romankurnovskii

explanations/2092/en.md

@@ -0,0 +1,60 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**Restate the problem:** We have n people, and person 0 initially knows a secret. At time 0, person 0 shares the secret with `firstPerson`. Then, through a series of meetings at different times, the secret spreads. When two people meet at the same time, if either knows the secret, both learn it. However, the secret can only spread within the same time frame - connections formed at one time don't carry over to future times unless those people remain connected to person 0.
+
+**1.1 Constraints & Complexity:**
+
+- **Input Size:** n can be up to 10^5, and there can be up to 10^5 meetings.
+- **Time Complexity:** O(M log M) where M is the number of meetings - we sort meetings by time (O(M log M)) and process them with Union-Find operations (nearly O(1) per operation).
+- **Space Complexity:** O(n) for the Union-Find data structure.
+- **Edge Case:** If no meetings occur, only person 0 and firstPerson know the secret.
+
+**1.2 High-level approach:**
+
+The goal is to track which people know the secret by processing meetings in chronological order. At each time step, we temporarily connect people who meet, let the secret spread within that group, then only keep connections to person 0. People not connected to person 0 "forget" their temporary connections.
+
+**1.3 Brute force vs. optimized strategy:**
+
+- **Brute Force:** For each time, create a graph of all meetings, run BFS/DFS to find all connected components that include person 0, then reset. This would be O(M \* n) in worst case.
+- **Optimized Strategy:** Use Union-Find to efficiently connect people at the same time, then reset only those not connected to person 0. This is O(M log M) due to sorting.
+- **Optimization:** Union-Find provides nearly constant-time union and find operations, making it ideal for this dynamic connectivity problem.
+
+**1.4 Decomposition:**
+
+1. Sort all meetings by time to process them chronologically.
+2. Initialize Union-Find data structure and connect person 0 with firstPerson.
+3. For each unique time, process all meetings at that time by connecting the participants.
+4. After processing each time block, reset connections for people not connected to person 0.
+5. Return all people who are connected to person 0 after all meetings.
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+
+Let's use the example: `n = 6, meetings = [[1,2,5],[2,3,8],[1,5,10]], firstPerson = 1`
+
+- Initially, person 0 and person 1 know the secret.
+- We initialize parent array: `parent = [0, 1, 2, 3, 4, 5]`
+- After connecting 0 and 1: `parent = [0, 0, 2, 3, 4, 5]`
+
+**2.2 Start Processing:**
+
+We sort meetings by time: `[[1,2,5], [2,3,8], [1,5,10]]` (already sorted).
+
+**2.3 Trace Walkthrough:**
+
+| Time | Meeting  | Action        | Parent Array After Union | After Reset                                      |
+| ---- | -------- | ------------- | ------------------------ | ------------------------------------------------ |
+| 5    | [1,2,5]  | Union 1 and 2 | [0, 0, 0, 3, 4, 5]       | [0, 0, 0, 3, 4, 5] (all connected to 0)          |
+| 8    | [2,3,8]  | Union 2 and 3 | [0, 0, 0, 0, 4, 5]       | [0, 0, 0, 0, 4, 5] (all connected to 0)          |
+| 10   | [1,5,10] | Union 1 and 5 | [0, 0, 0, 0, 4, 0]       | [0, 0, 0, 0, 4, 0] (all except 4 connected to 0) |
+
+**2.4 Increment and Loop:**
+
+After processing each time block, we check which people are still connected to person 0. Those not connected have their parent reset to themselves, effectively "forgetting" the temporary connection.
+
+**2.5 Return Result:**
+
+The result is `[0, 1, 2, 3, 5]` - all people connected to person 0 after all meetings have been processed.

explanations/3693/en.md

@@ -0,0 +1,68 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**Restate the problem:** We need to climb a staircase with n+1 steps (numbered 0 to n), starting at step 0. From step i, we can jump to step i+1, i+2, or i+3. The cost of jumping from step i to step j is `costs[j] + (j - i)^2`. We want to find the minimum total cost to reach step n.
+
+**1.1 Constraints & Complexity:**
+
+- **Input Size:** n can be up to 10^5, and each cost is between 1 and 10^4.
+- **Time Complexity:** O(n) - we iterate through all n steps once, computing the minimum cost for each step.
+- **Space Complexity:** O(1) - we use a rolling array of size 3 instead of storing all n values, trading space for constant memory usage.
+- **Edge Case:** If n = 1, we can only jump from step 0 to step 1 with cost `costs[0] + 1`.
+
+**1.2 High-level approach:**
+
+The goal is to compute the minimum cost to reach each step by considering the three possible previous steps (i-1, i-2, i-3) and choosing the one with minimum total cost.
+
+**1.3 Brute force vs. optimized strategy:**
+
+- **Brute Force:** Recursively try all paths from step 0 to step n, which would be O(3^n) exponential time.
+- **Optimized Strategy:** Use dynamic programming with a rolling array. For each step i, we only need the costs of steps i-1, i-2, and i-3, so we can use a 3-element array and update it in place. This is O(n) time and O(1) space.
+- **Optimization:** Since we only need the last 3 values at any time, we use a rolling array instead of storing all n values, reducing space from O(n) to O(1).
+
+**1.4 Decomposition:**
+
+1. Initialize three variables to represent the minimum cost to reach the previous three steps (initially all 0 for step 0).
+2. For each step from 1 to n, calculate the minimum cost by considering jumps from the three previous steps.
+3. Update the rolling array by shifting values: the oldest value is discarded, and the new value becomes the minimum cost for the current step.
+4. Return the cost to reach step n.
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+
+Let's use the example: `n = 4, costs = [1, 2, 3, 4]`
+
+- We start at step 0 with cost 0.
+- Initialize: `v0 = 0, v1 = 0, v2 = 0` (costs to reach steps -2, -1, 0, which are all 0)
+
+**2.2 Start Processing:**
+
+We iterate through each cost in the costs array, computing the minimum cost to reach each step.
+
+**2.3 Trace Walkthrough:**
+
+| Step | Cost | v0 | v1 | v2 | Calculation | New v2 |
+|------|------|----|----|----|-------------|--------|
+| 0 | - | 0 | 0 | 0 | Initial state | - |
+| 1 | 1 | 0 | 0 | 0 | min(0+9, 0+4, 0+1) + 1 = 1 | 1 |
+| 2 | 2 | 0 | 0 | 1 | min(0+9, 0+4, 1+1) + 2 = 4 | 4 |
+| 3 | 3 | 0 | 1 | 4 | min(0+9, 1+4, 4+1) + 3 = 8 | 8 |
+| 4 | 4 | 1 | 4 | 8 | min(1+9, 4+4, 8+1) + 4 = 13 | 13 |
+
+After each iteration, we shift: `v0, v1, v2 = v1, v2, new_value`
+
+**2.4 Increment and Loop:**
+
+For each step i, we compute:
+- Jump from i-3: `v0 + 9 + costs[i-1]`
+- Jump from i-2: `v1 + 4 + costs[i-1]`
+- Jump from i-1: `v2 + 1 + costs[i-1]`
+
+We take the minimum of these three options.
+
+**2.5 Return Result:**
+
+The result is `13`, which is the minimum cost to reach step 4. The optimal path is 0 → 1 → 2 → 4 with costs: (1+1) + (2+1) + (4+4) = 2 + 3 + 8 = 13.
+

explanations/3716/en.md

@@ -0,0 +1,68 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**Restate the problem:** We need to find customers at risk of churning based on their subscription history. A customer is at churn risk if they: (1) currently have an active subscription (last event is not cancel), (2) have performed at least one downgrade, (3) their current monthly amount is less than 50% of their historical maximum, and (4) have been a subscriber for at least 60 days.
+
+**1.1 Constraints & Complexity:**
+
+- **Input Size:** The subscription_events table can have many rows per user, with multiple events over time.
+- **Time Complexity:** O(n log n) where n is the number of events - window functions require sorting, and the EXISTS clause checks for downgrades.
+- **Space Complexity:** O(n) for the CTE that stores window function results.
+- **Edge Case:** A user who cancels and then starts again should only be considered based on their current active subscription period.
+
+**1.2 High-level approach:**
+
+The goal is to use window functions to compute aggregate statistics (max event date, max monthly amount, subscription duration) for each user, then filter based on the churn risk criteria.
+
+**1.3 Brute force vs. optimized strategy:**
+
+- **Brute Force:** Use multiple subqueries or self-joins to compute max dates, max amounts, and check for downgrades separately for each user. This would be O(n^2) in worst case.
+- **Optimized Strategy:** Use window functions (MAX() OVER()) to compute all aggregates in a single pass, then filter in the WHERE clause. This is O(n log n) due to window function sorting.
+- **Optimization:** Window functions allow us to compute multiple aggregates simultaneously without multiple table scans, and the EXISTS clause efficiently checks for downgrade events.
+
+**1.4 Decomposition:**
+
+1. Create a CTE that computes window functions for each event: max event date, max monthly amount, and subscription duration (max date - min date).
+2. Filter to only the most recent event for each user (where event_date = max_event_date).
+3. Apply churn risk criteria: active subscription, has downgrade, current amount < 50% of max, duration >= 60 days.
+4. Order results by days_as_subscriber DESC, then user_id ASC.
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+
+Let's consider a user with events:
+- 2024-01-01: start premium ($29.99)
+- 2024-02-15: downgrade standard ($19.99)
+- 2024-03-20: downgrade basic ($9.99)
+
+**2.2 Start Processing:**
+
+The CTE computes for each row:
+- `max_event_date`: 2024-03-20 (for all rows of this user)
+- `max_historical_amount`: $29.99 (for all rows)
+- `days_as_subscriber`: 79 days (2024-03-20 - 2024-01-01)
+
+**2.3 Trace Walkthrough:**
+
+| user_id | event_date | max_event_date | event_type | monthly_amount | max_historical_amount | days_as_subscriber | Keep? |
+|---------|------------|----------------|------------|----------------|----------------------|-------------------|-------|
+| 501 | 2024-01-01 | 2024-03-20 | start | 29.99 | 29.99 | 79 | No (not latest) |
+| 501 | 2024-02-15 | 2024-03-20 | downgrade | 19.99 | 29.99 | 79 | No (not latest) |
+| 501 | 2024-03-20 | 2024-03-20 | downgrade | 9.99 | 29.99 | 79 | Yes (meets all criteria) |
+
+After filtering to latest event and applying criteria:
+- Active? Yes (downgrade, not cancel)
+- Has downgrade? Yes (EXISTS finds downgrade events)
+- Current < 50% max? Yes (9.99 / 29.99 = 33.3% < 50%)
+- Duration >= 60? Yes (79 >= 60)
+
+**2.4 Increment and Loop:**
+
+The window functions process all events for all users, computing aggregates efficiently. The WHERE clause then filters to only churn risk customers.
+
+**2.5 Return Result:**
+
+The result includes user 501 with current_plan='basic', current_monthly_amount=9.99, max_historical_amount=29.99, and days_as_subscriber=79, ordered by days_as_subscriber DESC, user_id ASC.
+

solutions/2092/01.py

@@ -0,0 +1,41 @@
+class Solution:
+    def findAllPeople(self, n: int, meetings: List[List[int]], firstPerson: int) -> List[int]:
+        parent = list(range(n))
+
+        def find(x):
+            if parent[x] != x:
+                parent[x] = find(parent[x])
+            return parent[x]
+
+        def union(a, b):
+            parent[find(b)] = find(a)
+
+        # Sort meetings by time
+        meetings.sort(key=lambda x: x[2])
+
+        # Initially, person 0 and firstPerson know the secret
+        union(0, firstPerson)
+
+        i = 0
+        while i < len(meetings):
+            time = meetings[i][2]
+            involved = []
+
+            # Process all meetings at the same time
+            while i < len(meetings) and meetings[i][2] == time:
+                x, y, _ = meetings[i]
+                union(x, y)
+                involved.append(x)
+                involved.append(y)
+                i += 1
+
+            # Reset connections that don't include person 0
+            # Only people connected to person 0 keep the secret
+            root0 = find(0)
+            for p in involved:
+                if find(p) != root0:
+                    parent[p] = p
+
+        # Return all people connected to person 0
+        return [i for i in range(n) if find(i) == find(0)]
+

solutions/3693/01.py

@@ -0,0 +1,14 @@
+class Solution:
+    def climbStairs(self, n: int, costs: List[int]) -> int:
+        # Use rolling array of size 3 to save space
+        # dp[i] represents minimum cost to reach step i
+        v0 = v1 = v2 = 0
+        
+        for i, c in enumerate(costs):
+            # From step i, we can reach step i+1, i+2, or i+3
+            # Cost = previous cost + jump cost (1, 4, or 9) + step cost
+            v = min(v0 + 9, v1 + 4, v2 + 1) + c
+            v0, v1, v2 = v1, v2, v
+        
+        return v2
+

solutions/3716/01.sql

@@ -0,0 +1,31 @@
+WITH query_cte AS (
+    SELECT 
+        user_id, 
+        event_date, 
+        MAX(event_date) OVER(PARTITION BY user_id) max_event_date, 
+        event_type, 
+        plan_name current_plan, 
+        monthly_amount,
+        MAX(monthly_amount) OVER(PARTITION BY user_id) max_historical_amount,
+        DATEDIFF(MAX(event_date) OVER(PARTITION BY user_id), MIN(event_date) OVER(PARTITION BY user_id)) days_as_subscriber
+    FROM subscription_events
+)
+SELECT 
+    user_id, 
+    current_plan, 
+    monthly_amount current_monthly_amount, 
+    max_historical_amount, 
+    days_as_subscriber
+FROM query_cte q
+WHERE event_date = max_event_date 
+    AND EXISTS (
+        SELECT 1 
+        FROM query_cte q1 
+        WHERE q.user_id = q1.user_id 
+            AND q1.event_type = 'downgrade'
+    )
+    AND days_as_subscriber > 59 
+    AND monthly_amount / CAST(max_historical_amount AS FLOAT) <= 0.5 
+    AND event_type <> 'cancel'
+ORDER BY days_as_subscriber DESC, user_id;
+