feat: add solutions to lc problem: No.1267

No.1267.Count Servers that Communicate

Author: yanglbme

solution/1200-1299/1267.Count Servers that Communicate/README.md

@@ -56,11 +56,13 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-对每一行、每一列的服务器数量进行统计。
+**方法一：计数**
 
-然后遍历每个服务器，若当前服务器所在的行或者列的服务器数量超过 1，说明当前服务器满足条件，累加结果 res。
+我们可以统计每一行、每一列的服务器数量，然后遍历每个服务器，若当前服务器所在的行或者列的服务器数量超过 1，说明当前服务器满足条件，结果加 $1$。
 
-遍历结束后，返回 res 即可。
+遍历结束后，返回结果即可。
+
+时间复杂度 $O(m \times n)$，空间复杂度 $O(m + n)$。其中 $m$ 和 $n$ 分别为矩阵的行数和列数。
 
 <!-- tabs:start -->
 
@@ -72,20 +74,18 @@
 class Solution:
     def countServers(self, grid: List[List[int]]) -> int:
         m, n = len(grid), len(grid[0])
-        rows = [0] * m
-        cols = [0] * n
-        for i in range(m):
-            for j in range(n):
-                if grid[i][j] == 1:
-                    rows[i] += 1
-                    cols[j] += 1
-        res = 0
+        row = [0] * m
+        col = [0] * n
         for i in range(m):
             for j in range(n):
-                if grid[i][j] == 1:
-                    if rows[i] > 1 or cols[j] > 1:
-                        res += 1
-        return res
+                if grid[i][j]:
+                    row[i] += 1
+                    col[j] += 1
+        return sum(
+            grid[i][j] and (row[i] > 1 or col[j] > 1)
+            for i in range(m)
+            for j in range(n)
+        )
 ```
 
 ### **Java**
@@ -96,27 +96,25 @@ class Solution:
 class Solution {
     public int countServers(int[][] grid) {
         int m = grid.length, n = grid[0].length;
-        int[] rows = new int[m];
-        int[] cols = new int[n];
+        int[] row = new int[m];
+        int[] col = new int[n];
         for (int i = 0; i < m; ++i) {
             for (int j = 0; j < n; ++j) {
                 if (grid[i][j] == 1) {
-                    ++rows[i];
-                    ++cols[j];
+                    row[i]++;
+                    col[j]++;
                 }
             }
         }
-        int res = 0;
+        int ans = 0;
         for (int i = 0; i < m; ++i) {
             for (int j = 0; j < n; ++j) {
-                if (grid[i][j] == 1) {
-                    if (rows[i] > 1 || cols[j] > 1) {
-                        ++res;
-                    }
+                if (grid[i][j] == 1 && (row[i] > 1 || col[j] > 1)) {
+                    ++ans;
                 }
             }
         }
-        return res;
+        return ans;
     }
 }
 ```
@@ -128,57 +126,76 @@ class Solution {
 public:
     int countServers(vector<vector<int>>& grid) {
         int m = grid.size(), n = grid[0].size();
-        vector<int> rows(m);
-        vector<int> cols(n);
+        vector<int> row(m), col(n);
         for (int i = 0; i < m; ++i) {
             for (int j = 0; j < n; ++j) {
-                if (grid[i][j] == 1) {
-                    ++rows[i];
-                    ++cols[j];
+                if (grid[i][j]) {
+                    ++row[i];
+                    ++col[j];
                 }
             }
         }
-        int res = 0;
+        int ans = 0;
         for (int i = 0; i < m; ++i) {
             for (int j = 0; j < n; ++j) {
-                if (grid[i][j] == 1) {
-                    if (rows[i] > 1 || cols[j] > 1) {
-                        ++res;
-                    }
-                }
+                ans += grid[i][j] && (row[i] > 1 || col[j] > 1);
             }
         }
-        return res;
+        return ans;
     }
 };
 ```
 
 ### **Go**
 
 ```go
-func countServers(grid [][]int) int {
+func countServers(grid [][]int) (ans int) {
 	m, n := len(grid), len(grid[0])
-	rows := make([]int, m)
-	cols := make([]int, n)
-	for i := 0; i < m; i++ {
-		for j := 0; j < n; j++ {
-			if grid[i][j] == 1 {
-				rows[i]++
-				cols[j]++
+	row, col := make([]int, m), make([]int, n)
+	for i := range grid {
+		for j, x := range grid[i] {
+			if x == 1 {
+				row[i]++
+				col[j]++
 			}
 		}
 	}
-	res := 0
-	for i := 0; i < m; i++ {
-		for j := 0; j < n; j++ {
-			if grid[i][j] == 1 {
-				if rows[i] > 1 || cols[j] > 1 {
-					res++
-				}
+	for i := range grid {
+		for j, x := range grid[i] {
+			if x == 1 && (row[i] > 1 || col[j] > 1) {
+				ans++
 			}
 		}
 	}
-	return res
+	return
+}
+```
+
+### **TypeScript**
+
+```ts
+function countServers(grid: number[][]): number {
+    const m = grid.length;
+    const n = grid[0].length;
+    const row = new Array(m).fill(0);
+    const col = new Array(n).fill(0);
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            if (grid[i][j] === 1) {
+                row[i]++;
+                col[j]++;
+            }
+        }
+    }
+    let ans = 0;
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            if (grid[i][j] === 1 && (row[i] > 1 || col[j] > 1)) {
+                ans++;
+            }
+        }
+    }
+    return ans;
 }
 ```
 

solution/1200-1299/1267.Count Servers that Communicate/README_EN.md

@@ -59,20 +59,18 @@ Return the number of servers&nbsp;that communicate with any other server.</p>
 class Solution:
     def countServers(self, grid: List[List[int]]) -> int:
         m, n = len(grid), len(grid[0])
-        rows = [0] * m
-        cols = [0] * n
+        row = [0] * m
+        col = [0] * n
         for i in range(m):
             for j in range(n):
-                if grid[i][j] == 1:
-                    rows[i] += 1
-                    cols[j] += 1
-        res = 0
-        for i in range(m):
-            for j in range(n):
-                if grid[i][j] == 1:
-                    if rows[i] > 1 or cols[j] > 1:
-                        res += 1
-        return res
+                if grid[i][j]:
+                    row[i] += 1
+                    col[j] += 1
+        return sum(
+            grid[i][j] and (row[i] > 1 or col[j] > 1)
+            for i in range(m)
+            for j in range(n)
+        )
 ```
 
 ### **Java**
@@ -81,27 +79,25 @@ class Solution:
 class Solution {
     public int countServers(int[][] grid) {
         int m = grid.length, n = grid[0].length;
-        int[] rows = new int[m];
-        int[] cols = new int[n];
+        int[] row = new int[m];
+        int[] col = new int[n];
         for (int i = 0; i < m; ++i) {
             for (int j = 0; j < n; ++j) {
                 if (grid[i][j] == 1) {
-                    ++rows[i];
-                    ++cols[j];
+                    row[i]++;
+                    col[j]++;
                 }
             }
         }
-        int res = 0;
+        int ans = 0;
         for (int i = 0; i < m; ++i) {
             for (int j = 0; j < n; ++j) {
-                if (grid[i][j] == 1) {
-                    if (rows[i] > 1 || cols[j] > 1) {
-                        ++res;
-                    }
+                if (grid[i][j] == 1 && (row[i] > 1 || col[j] > 1)) {
+                    ++ans;
                 }
             }
         }
-        return res;
+        return ans;
     }
 }
 ```
@@ -113,57 +109,76 @@ class Solution {
 public:
     int countServers(vector<vector<int>>& grid) {
         int m = grid.size(), n = grid[0].size();
-        vector<int> rows(m);
-        vector<int> cols(n);
+        vector<int> row(m), col(n);
         for (int i = 0; i < m; ++i) {
             for (int j = 0; j < n; ++j) {
-                if (grid[i][j] == 1) {
-                    ++rows[i];
-                    ++cols[j];
+                if (grid[i][j]) {
+                    ++row[i];
+                    ++col[j];
                 }
             }
         }
-        int res = 0;
+        int ans = 0;
         for (int i = 0; i < m; ++i) {
             for (int j = 0; j < n; ++j) {
-                if (grid[i][j] == 1) {
-                    if (rows[i] > 1 || cols[j] > 1) {
-                        ++res;
-                    }
-                }
+                ans += grid[i][j] && (row[i] > 1 || col[j] > 1);
             }
         }
-        return res;
+        return ans;
     }
 };
 ```
 
 ### **Go**
 
 ```go
-func countServers(grid [][]int) int {
+func countServers(grid [][]int) (ans int) {
 	m, n := len(grid), len(grid[0])
-	rows := make([]int, m)
-	cols := make([]int, n)
-	for i := 0; i < m; i++ {
-		for j := 0; j < n; j++ {
-			if grid[i][j] == 1 {
-				rows[i]++
-				cols[j]++
+	row, col := make([]int, m), make([]int, n)
+	for i := range grid {
+		for j, x := range grid[i] {
+			if x == 1 {
+				row[i]++
+				col[j]++
 			}
 		}
 	}
-	res := 0
-	for i := 0; i < m; i++ {
-		for j := 0; j < n; j++ {
-			if grid[i][j] == 1 {
-				if rows[i] > 1 || cols[j] > 1 {
-					res++
-				}
+	for i := range grid {
+		for j, x := range grid[i] {
+			if x == 1 && (row[i] > 1 || col[j] > 1) {
+				ans++
 			}
 		}
 	}
-	return res
+	return
+}
+```
+
+### **TypeScript**
+
+```ts
+function countServers(grid: number[][]): number {
+    const m = grid.length;
+    const n = grid[0].length;
+    const row = new Array(m).fill(0);
+    const col = new Array(n).fill(0);
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            if (grid[i][j] === 1) {
+                row[i]++;
+                col[j]++;
+            }
+        }
+    }
+    let ans = 0;
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            if (grid[i][j] === 1 && (row[i] > 1 || col[j] > 1)) {
+                ans++;
+            }
+        }
+    }
+    return ans;
 }
 ```
 

solution/1200-1299/1267.Count Servers that Communicate/Solution.cpp

@@ -2,26 +2,21 @@ class Solution {
 public:
     int countServers(vector<vector<int>>& grid) {
         int m = grid.size(), n = grid[0].size();
-        vector<int> rows(m);
-        vector<int> cols(n);
+        vector<int> row(m), col(n);
         for (int i = 0; i < m; ++i) {
             for (int j = 0; j < n; ++j) {
-                if (grid[i][j] == 1) {
-                    ++rows[i];
-                    ++cols[j];
+                if (grid[i][j]) {
+                    ++row[i];
+                    ++col[j];
                 }
             }
         }
-        int res = 0;
+        int ans = 0;
         for (int i = 0; i < m; ++i) {
             for (int j = 0; j < n; ++j) {
-                if (grid[i][j] == 1) {
-                    if (rows[i] > 1 || cols[j] > 1) {
-                        ++res;
-                    }
-                }
+                ans += grid[i][j] && (row[i] > 1 || col[j] > 1);
             }
         }
-        return res;
+        return ans;
     }
 };