feat: add solutions to lc problem: No.3531

solution/3500-3599/3531.Count Covered Buildings/README.md

@@ -112,32 +112,187 @@ tags:
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：哈希表 + 排序
+
+我们可以将建筑按照横坐标和纵坐标进行分组，分别记录在哈希表 $\text{g1}$ 和 $\text{g2}$ 中，其中 $\text{g1[x]}$ 表示所有横坐标为 $x$ 的纵坐标，而 $\text{g2[y]}$ 表示所有纵坐标为 $y$ 的横坐标，然后我们将其进行排序。
+
+接下来，我们遍历所有建筑，对于当前建筑 $(x, y)$，我们通过哈希表获取对应的纵坐标列表 $l_1$ 和横坐标列表 $l_2$，并检查条件以确定建筑是否被覆盖。覆盖的条件是 $l_2[0] < x < l_2[-1]$ 且 $l_1[0] < y < l_1[-1]$，若是，我们将答案加一。
+
+遍历结束后，返回答案即可。
+
+时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 是建筑物的数量。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def countCoveredBuildings(self, n: int, buildings: List[List[int]]) -> int:
+        g1 = defaultdict(list)
+        g2 = defaultdict(list)
+        for x, y in buildings:
+            g1[x].append(y)
+            g2[y].append(x)
+        for x in g1:
+            g1[x].sort()
+        for y in g2:
+            g2[y].sort()
+        ans = 0
+        for x, y in buildings:
+            l1 = g1[x]
+            l2 = g2[y]
+            if l2[0] < x < l2[-1] and l1[0] < y < l1[-1]:
+                ans += 1
+        return ans
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public int countCoveredBuildings(int n, int[][] buildings) {
+        Map<Integer, List<Integer>> g1 = new HashMap<>();
+        Map<Integer, List<Integer>> g2 = new HashMap<>();
+
+        for (int[] building : buildings) {
+            int x = building[0], y = building[1];
+            g1.computeIfAbsent(x, k -> new ArrayList<>()).add(y);
+            g2.computeIfAbsent(y, k -> new ArrayList<>()).add(x);
+        }
+
+        for (var e : g1.entrySet()) {
+            Collections.sort(e.getValue());
+        }
+        for (var e : g2.entrySet()) {
+            Collections.sort(e.getValue());
+        }
+
+        int ans = 0;
+
+        for (int[] building : buildings) {
+            int x = building[0], y = building[1];
+            List<Integer> l1 = g1.get(x);
+            List<Integer> l2 = g2.get(y);
+
+            if (l2.get(0) < x && x < l2.get(l2.size() - 1) && l1.get(0) < y
+                && y < l1.get(l1.size() - 1)) {
+                ans++;
+            }
+        }
+
+        return ans;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int countCoveredBuildings(int n, vector<vector<int>>& buildings) {
+        unordered_map<int, vector<int>> g1;
+        unordered_map<int, vector<int>> g2;
+
+        for (const auto& building : buildings) {
+            int x = building[0], y = building[1];
+            g1[x].push_back(y);
+            g2[y].push_back(x);
+        }
+
+        for (auto& e : g1) {
+            sort(e.second.begin(), e.second.end());
+        }
+        for (auto& e : g2) {
+            sort(e.second.begin(), e.second.end());
+        }
+
+        int ans = 0;
+
+        for (const auto& building : buildings) {
+            int x = building[0], y = building[1];
+            const vector<int>& l1 = g1[x];
+            const vector<int>& l2 = g2[y];
+
+            if (l2[0] < x && x < l2[l2.size() - 1] && l1[0] < y && y < l1[l1.size() - 1]) {
+                ans++;
+            }
+        }
+
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func countCoveredBuildings(n int, buildings [][]int) (ans int) {
+	g1 := make(map[int][]int)
+	g2 := make(map[int][]int)
+
+	for _, building := range buildings {
+		x, y := building[0], building[1]
+		g1[x] = append(g1[x], y)
+		g2[y] = append(g2[y], x)
+	}
+
+	for _, list := range g1 {
+		sort.Ints(list)
+	}
+	for _, list := range g2 {
+		sort.Ints(list)
+	}
+
+	for _, building := range buildings {
+		x, y := building[0], building[1]
+		l1 := g1[x]
+		l2 := g2[y]
+
+		if l2[0] < x && x < l2[len(l2)-1] && l1[0] < y && y < l1[len(l1)-1] {
+			ans++
+		}
+	}
+	return
+}
+```
+
+#### TypeScript
+
+```ts
+function countCoveredBuildings(n: number, buildings: number[][]): number {
+    const g1: Map<number, number[]> = new Map();
+    const g2: Map<number, number[]> = new Map();
+
+    for (const [x, y] of buildings) {
+        if (!g1.has(x)) g1.set(x, []);
+        g1.get(x)?.push(y);
+
+        if (!g2.has(y)) g2.set(y, []);
+        g2.get(y)?.push(x);
+    }
+
+    for (const list of g1.values()) {
+        list.sort((a, b) => a - b);
+    }
+    for (const list of g2.values()) {
+        list.sort((a, b) => a - b);
+    }
+
+    let ans = 0;
+
+    for (const [x, y] of buildings) {
+        const l1 = g1.get(x)!;
+        const l2 = g2.get(y)!;
+
+        if (l2[0] < x && x < l2[l2.length - 1] && l1[0] < y && y < l1[l1.length - 1]) {
+            ans++;
+        }
+    }
 
+    return ans;
+}
 ```
 
 <!-- tabs:end -->

solution/3500-3599/3531.Count Covered Buildings/README_EN.md

@@ -110,32 +110,187 @@ tags:
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Hash Table + Sorting
+
+We can group the buildings by their x-coordinates and y-coordinates, storing them in hash tables $\text{g1}$ and $\text{g2}$, respectively. Here, $\text{g1[x]}$ represents all y-coordinates for buildings with x-coordinate $x$, and $\text{g2[y]}$ represents all x-coordinates for buildings with y-coordinate $y$. Then, we sort these lists.
+
+Next, we iterate through all buildings. For the current building $(x, y)$, we retrieve the corresponding y-coordinate list $l_1$ from $\text{g1}$ and the x-coordinate list $l_2$ from $\text{g2}$. We check the conditions to determine whether the building is covered. A building is covered if $l_2[0] < x < l_2[-1]$ and $l_1[0] < y < l_1[-1]$. If so, we increment the answer by one.
+
+After finishing the iteration, we return the final answer.
+
+The complexity is $O(n \times \log n)$, and the space complexity is $O(n)$, where $n$ is the number of buildings.
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def countCoveredBuildings(self, n: int, buildings: List[List[int]]) -> int:
+        g1 = defaultdict(list)
+        g2 = defaultdict(list)
+        for x, y in buildings:
+            g1[x].append(y)
+            g2[y].append(x)
+        for x in g1:
+            g1[x].sort()
+        for y in g2:
+            g2[y].sort()
+        ans = 0
+        for x, y in buildings:
+            l1 = g1[x]
+            l2 = g2[y]
+            if l2[0] < x < l2[-1] and l1[0] < y < l1[-1]:
+                ans += 1
+        return ans
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public int countCoveredBuildings(int n, int[][] buildings) {
+        Map<Integer, List<Integer>> g1 = new HashMap<>();
+        Map<Integer, List<Integer>> g2 = new HashMap<>();
+
+        for (int[] building : buildings) {
+            int x = building[0], y = building[1];
+            g1.computeIfAbsent(x, k -> new ArrayList<>()).add(y);
+            g2.computeIfAbsent(y, k -> new ArrayList<>()).add(x);
+        }
+
+        for (var e : g1.entrySet()) {
+            Collections.sort(e.getValue());
+        }
+        for (var e : g2.entrySet()) {
+            Collections.sort(e.getValue());
+        }
+
+        int ans = 0;
+
+        for (int[] building : buildings) {
+            int x = building[0], y = building[1];
+            List<Integer> l1 = g1.get(x);
+            List<Integer> l2 = g2.get(y);
+
+            if (l2.get(0) < x && x < l2.get(l2.size() - 1) && l1.get(0) < y
+                && y < l1.get(l1.size() - 1)) {
+                ans++;
+            }
+        }
+
+        return ans;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int countCoveredBuildings(int n, vector<vector<int>>& buildings) {
+        unordered_map<int, vector<int>> g1;
+        unordered_map<int, vector<int>> g2;
+
+        for (const auto& building : buildings) {
+            int x = building[0], y = building[1];
+            g1[x].push_back(y);
+            g2[y].push_back(x);
+        }
+
+        for (auto& e : g1) {
+            sort(e.second.begin(), e.second.end());
+        }
+        for (auto& e : g2) {
+            sort(e.second.begin(), e.second.end());
+        }
+
+        int ans = 0;
+
+        for (const auto& building : buildings) {
+            int x = building[0], y = building[1];
+            const vector<int>& l1 = g1[x];
+            const vector<int>& l2 = g2[y];
+
+            if (l2[0] < x && x < l2[l2.size() - 1] && l1[0] < y && y < l1[l1.size() - 1]) {
+                ans++;
+            }
+        }
+
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func countCoveredBuildings(n int, buildings [][]int) (ans int) {
+	g1 := make(map[int][]int)
+	g2 := make(map[int][]int)
+
+	for _, building := range buildings {
+		x, y := building[0], building[1]
+		g1[x] = append(g1[x], y)
+		g2[y] = append(g2[y], x)
+	}
+
+	for _, list := range g1 {
+		sort.Ints(list)
+	}
+	for _, list := range g2 {
+		sort.Ints(list)
+	}
+
+	for _, building := range buildings {
+		x, y := building[0], building[1]
+		l1 := g1[x]
+		l2 := g2[y]
+
+		if l2[0] < x && x < l2[len(l2)-1] && l1[0] < y && y < l1[len(l1)-1] {
+			ans++
+		}
+	}
+	return
+}
+```
+
+#### TypeScript
+
+```ts
+function countCoveredBuildings(n: number, buildings: number[][]): number {
+    const g1: Map<number, number[]> = new Map();
+    const g2: Map<number, number[]> = new Map();
+
+    for (const [x, y] of buildings) {
+        if (!g1.has(x)) g1.set(x, []);
+        g1.get(x)?.push(y);
+
+        if (!g2.has(y)) g2.set(y, []);
+        g2.get(y)?.push(x);
+    }
+
+    for (const list of g1.values()) {
+        list.sort((a, b) => a - b);
+    }
+    for (const list of g2.values()) {
+        list.sort((a, b) => a - b);
+    }
+
+    let ans = 0;
+
+    for (const [x, y] of buildings) {
+        const l1 = g1.get(x)!;
+        const l2 = g2.get(y)!;
+
+        if (l2[0] < x && x < l2[l2.length - 1] && l1[0] < y && y < l1[l1.length - 1]) {
+            ans++;
+        }
+    }
 
+    return ans;
+}
 ```
 
 <!-- tabs:end -->