1267.统计参与通信的服务器：统计每行每列电脑数量

【LetMeFly】1267.统计参与通信的服务器：统计每行每列电脑数量

力扣题目链接：https://leetcode.cn/problems/count-servers-that-communicate/

这里有一幅服务器分布图，服务器的位置标识在 m * n 的整数矩阵网格 grid 中，1 表示单元格上有服务器，0 表示没有。

如果两台服务器位于同一行或者同一列，我们就认为它们之间可以进行通信。

请你统计并返回能够与至少一台其他服务器进行通信的服务器的数量。

 

示例 1：

输入：grid = [[1,0],[0,1]]
输出：0
解释：没有一台服务器能与其他服务器进行通信。

示例 2：

输入：grid = [[1,0],[1,1]]
输出：3
解释：所有这些服务器都至少可以与一台别的服务器进行通信。

示例 3：

输入：grid = [[1,1,0,0],[0,0,1,0],[0,0,1,0],[0,0,0,1]]
输出：4
解释：第一行的两台服务器互相通信，第三列的两台服务器互相通信，但右下角的服务器无法与其他服务器通信。

 

提示：

• m == grid.length
• n == grid[i].length
• 1 <= m <= 250
• 1 <= n <= 250
• grid[i][j] == 0 or 1

方法一：计数

假设$gird$的$size$为$n\times m$，开辟两个数组$row[n]$和$col[m]$，分别记录某行服务器个数 和 某列的服务器个数。

遍历一遍地图矩阵$grid$，若此处有服务器(server) 且 此行或此列不只一台服务器，则$ans++$

• 时间复杂度$O(n\times m)$
• 空间复杂度$O(n + m)$

AC代码

C++

/*
 * @LastEditTime: 2023-08-24 09:12:27
 */
class Solution {
public:
    int countServers(vector<vector<int>>& grid) {
        int n = grid.size(), m = grid[0].size();
        vector<int> row(n), col(m);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                row[i] += grid[i][j], col[j] += grid[i][j];
            }
        }
        int ans = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                ans += grid[i][j] * (row[i] > 1 || col[j] > 1);
            }
        }
        return ans;
    }
};

/*
 * @LastEditTime: 2026-11-08 10:49:20
 */
class Solution {
public:
    int countServers(vector<vector<int>>& grid) {
        int n = grid.size(), m = grid[0].size();
        vector<int> line(n), row(m);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j]) {
                    line[i]++;
                    row[j]++;
                }
            }
        }

        int ans = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                ans += grid[i][j] && (line[i] > 1 || row[j] > 1);
            }
        }
        return ans;
    }
};

Python

# from typing import List

class Solution:
    def countServers(self, grid: List[List[int]]) -> int:
        n, m = len(grid), len(grid[0])
        col, row = [0] * n, [0] * m
        for i in range(n):
            for j in range(m):
                col[i] += grid[i][j]
                row[j] += grid[i][j]
        ans = 0
        for i in range(n):
            for j in range(m):
                ans += grid[i][j] * (col[i] > 1 or row[j] > 1)
        return ans

'''
LastEditTime: 2026-11-08 10:56:14
'''
class Solution:
    def countServers(self, grid: list[list[int]]) -> int:
        n, m = len(grid), len(grid[0])
        a, b = [0] * n, [0] * m
        for i, row in enumerate(grid):
            for j, v in enumerate(row):
                if v:
                    a[i] += 1
                    b[j] += 1
        
        ans = 0
        for i, row in enumerate(grid):
            for j, v in enumerate(row):
                if v and (a[i] > 1 or b[j] > 1):
                    ans += 1
        return ans

Java

/*
 * @LastEditTime: 2026-11-08 10:54:31
 */
class Solution {
    public int countServers(int[][] grid) {
        int n = grid.length;
        int m = grid[0].length;
        int[] a = new int[n];
        int[] b = new int[m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1) {
                    a[i]++;
                    b[j]++;
                }
            }
        }

        int ans = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1 && (a[i] > 1 || b[j] > 1)) {
                    ans++;
                }
            }
        }
        return ans;
    }
}

Go

/*
 * @LastEditTime: 2026-11-08 10:52:49
 */
package main

func countServers(grid [][]int) (ans int) {
    n, m := len(grid), len(grid[0])
    a, b := make([]int, n), make([]int, m)
    for i, row := range grid {
        for j, v := range row {
            if v == 1 {
                a[i]++
                b[j]++
            }
        }
    }

    for i, row := range grid {
        for j, v := range row {
            if v == 1 && (a[i] > 1 || b[j] > 1) {
                ans++
            }
        }
    }
    return
}

Rust

/*
 * @LastEditTime: 2026-11-08 10:58:49
 */
impl Solution {
    pub fn count_servers(grid: Vec<Vec<i32>>) -> i32 {
        let n = grid.len();
        let m = grid[0].len();
        let mut a = vec![0; n];
        let mut b = vec![0; m];
        for i in 0..n {
            for j in 0..m {
                if grid[i][j] == 1 {
                    a[i] += 1;
                    b[j] += 1;
                }
            }
        }

        let mut ans = 0;
        for i in 0..n {
            for j in 0..m {
                if grid[i][j] == 1 && (a[i] > 1 || b[j] > 1) {
                    ans += 1;
                }
            }
        }
        ans
    }
}

End

同步发文于CSDN和我的个人博客，原创不易，转载经作者同意后请附上原文链接哦~

千篇源码题解已开源