chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Hard/2025-12-03-3625-Count-Number-of-Trapezoids-II/explanation.md

@@ -0,0 +1,31 @@
+# Count Number of Trapezoids II (Hard)
+
+**Problem ID:** 3625  
+**Date:** 2025-12-03  
+**Link:** https://leetcode.com/problems/count-number-of-trapezoids-ii/
+
+## Approach
+
+To solve the problem of counting unique trapezoids that can be formed from a set of points on a Cartesian plane, we can follow a systematic approach based on the properties of trapezoids and the concept of slopes.
+
+### Main Idea:
+A trapezoid is defined as a convex quadrilateral with at least one pair of parallel sides. To identify trapezoids from a set of points, we can leverage the fact that two sides are parallel if they have the same slope. Therefore, the key steps involve calculating the slopes between pairs of points and grouping points that share the same slope.
+
+### Approach:
+1. **Calculate Slopes**: For each pair of points, compute the slope. The slope between two points \((x_1, y_1)\) and \((x_2, y_2)\) can be represented as a fraction \((y_2 - y_1) / (x_2 - x_1)\). To avoid floating-point inaccuracies and division by zero, we can represent slopes as pairs of integers (dy, dx) reduced to their simplest form using the greatest common divisor (GCD).
+
+2. **Group Points by Slopes**: Use a dictionary to group points that share the same slope. For each point, maintain a mapping of slopes to the list of points that can be reached from it with that slope.
+
+3. **Count Trapezoids**: For each unique slope group, if there are \(n\) points that share the same slope, we can choose any two points from these \(n\) points to form one pair of parallel sides. The number of ways to choose 2 points from \(n\) is given by \(\binom{n}{2} = n(n-1)/2\). For each pair of parallel sides, we need to find points from the other slope groups to form the remaining two sides of the trapezoid.
+
+4. **Combine Results**: For each combination of two pairs of parallel sides (from different slope groups), check if they can form a trapezoid and count them.
+
+### Data Structures:
+- A dictionary (or hashmap) to store slopes as keys and lists of points as values.
+- A set to keep track of unique trapezoids to avoid counting duplicates.
+
+### Complexity:
+- **Time Complexity**: The algorithm primarily involves iterating through pairs of points to calculate slopes, leading to a time complexity of \(O(n^2)\), where \(n\) is the number of points. The subsequent operations to count trapezoids depend on the number of unique slopes and points associated with them.
+- **Space Complexity**: The space complexity is \(O(n)\) for storing the points in the slope dictionary.
+
+This approach effectively reduces the problem to manageable components by focusing on the geometric properties of trapezoids and utilizing combinatorial counting, thus allowing us to efficiently count the number of unique trapezoids formed by the given points.

Hard/2025-12-03-3625-Count-Number-of-Trapezoids-II/solution.java

@@ -0,0 +1,45 @@
+import java.util.HashMap;
+import java.util.Map;
+
+public class Solution {
+    public int countTrapezoids(int[][] points) {
+        int n = points.length;
+        Map<Integer, Map<Integer, Integer>> slopeCount = new HashMap<>();
+        int trapezoidCount = 0;
+
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                if (points[i][1] != points[j][1]) {
+                    int dx = points[j][0] - points[i][0];
+                    int dy = points[j][1] - points[i][1];
+                    int gcd = gcd(dx, dy);
+                    dx /= gcd;
+                    dy /= gcd;
+
+                    slopeCount.putIfAbsent(dy, new HashMap<>());
+                    slopeCount.get(dy).putIfAbsent(dx, 0);
+                    slopeCount.get(dy).put(dx, slopeCount.get(dy).get(dx) + 1);
+                }
+            }
+        }
+
+        for (Map<Integer, Integer> map : slopeCount.values()) {
+            for (int count : map.values()) {
+                if (count >= 2) {
+                    trapezoidCount += count * (count - 1) / 2;
+                }
+            }
+        }
+
+        return trapezoidCount;
+    }
+
+    private int gcd(int a, int b) {
+        while (b != 0) {
+            int temp = b;
+            b = a % b;
+            a = temp;
+        }
+        return a;
+    }
+}

Hard/2025-12-03-3625-Count-Number-of-Trapezoids-II/solution.js

@@ -0,0 +1,35 @@
+var countTrapezoids = function(points) {
+    const slopes = new Map();
+    const n = points.length;
+
+    for (let i = 0; i < n; i++) {
+        for (let j = i + 1; j < n; j++) {
+            const dx = points[j][0] - points[i][0];
+            const dy = points[j][1] - points[i][1];
+            const gcd = getGCD(dx, dy);
+            const slope = `${dy / gcd},${dx / gcd}`;
+            if (!slopes.has(slope)) {
+                slopes.set(slope, new Set());
+            }
+            slopes.get(slope).add(`${points[i][0]},${points[i][1]}`);
+            slopes.get(slope).add(`${points[j][0]},${points[j][1]}`);
+        }
+    }
+
+    let count = 0;
+    for (const set of slopes.values()) {
+        const size = set.size;
+        if (size >= 4) {
+            count += (size * (size - 1) * (size - 2) * (size - 3)) / 24;
+        }
+    }
+
+    return count;
+};
+
+function getGCD(a, b) {
+    while (b) {
+        [a, b] = [b, a % b];
+    }
+    return a;
+}

Hard/2025-12-03-3625-Count-Number-of-Trapezoids-II/solution.py

@@ -0,0 +1,29 @@
+from collections import defaultdict
+from itertools import combinations
+
+class Solution:
+    def countTrapezoids(self, points: List[List[int]]) -> int:
+        slopes = defaultdict(set)
+        n = len(points)
+        
+        for i in range(n):
+            for j in range(i + 1, n):
+                if points[i][0] != points[j][0]:  # Avoid vertical lines
+                    slope = (points[j][1] - points[i][1], points[j][0] - points[i][0])
+                    gcd = self.gcd(slope[0], slope[1])
+                    slope = (slope[0] // gcd, slope[1] // gcd)
+                    slopes[slope].add((i, j))
+        
+        trapezoid_count = 0
+        
+        for pairs in slopes.values():
+            m = len(pairs)
+            if m >= 2:
+                trapezoid_count += m * (m - 1) // 2
+        
+        return trapezoid_count
+
+    def gcd(self, a: int, b: int) -> int:
+        while b:
+            a, b = b, a % b
+        return abs(a)

README.md

@@ -293,3 +293,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2025-11-30 — [Make Sum Divisible by P](https://leetcode.com/problems/make-sum-divisible-by-p/) (Medium) → `Medium/2025-11-30-1590-Make-Sum-Divisible-by-P`
 - 2025-12-01 — [Maximum Running Time of N Computers](https://leetcode.com/problems/maximum-running-time-of-n-computers/) (Hard) → `Hard/2025-12-01-2141-Maximum-Running-Time-of-N-Computers`
 - 2025-12-02 — [Count Number of Trapezoids I](https://leetcode.com/problems/count-number-of-trapezoids-i/) (Medium) → `Medium/2025-12-02-3623-Count-Number-of-Trapezoids-I`
+- 2025-12-03 — [Count Number of Trapezoids II](https://leetcode.com/problems/count-number-of-trapezoids-ii/) (Hard) → `Hard/2025-12-03-3625-Count-Number-of-Trapezoids-II`