1267-统计参与通信的服务器

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

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

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

示例 1：

![](https://assets.leetcode-cn.com/aliyun-lc-
upload/uploads/2019/11/24/untitled-diagram-6.jpg)

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

示例 2：

![](https://assets.leetcode-cn.com/aliyun-lc-
upload/uploads/2019/11/24/untitled-diagram-4-1.jpg)

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

示例 3：

![](https://assets.leetcode-cn.com/aliyun-lc-
upload/uploads/2019/11/24/untitled-diagram-1-3.jpg)

**输入：** 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

方法一：两次遍历 + 哈希表

思路与算法

我们可以使用两次遍历解决本题。

在第一次遍历中，我们遍历数组 grid，如果 grid}[i, j] 的值为 1，说明位置 (i, j) 有一台服务器，我们可以将第 i 行服务器的数量，以及第 j 列服务器的数量，均加上 1。为了维护行列中服务器的数量，我们可以使用两个哈希映射 row 和 col，row 中存储行的编号以及每一行服务器的数量，col 存储列的编号以及每一列服务器的数量。

在第二次遍历中，我们就可以根据 row 和 col 来判断每一台服务器是否能与至少其它一台服务器进行通信了。如果 grid}(i, j) 的值为 1，并且 row}[i] 和 col}[j] 中至少有一个严格大于 1，就说明位置 (i, j) 的服务器能与同一行或者同一列的另一台服务器进行通信，答案加 1。

代码

[sol1-C++]

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

[sol1-Java]

class Solution {
    public int countServers(int[][] grid) {
        int m = grid.length, n = grid[0].length;
        Map<Integer, Integer> rows = new HashMap<Integer, Integer>();
        Map<Integer, Integer> cols = new HashMap<Integer, Integer>();
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (grid[i][j] == 1) {
                    rows.put(i, rows.getOrDefault(i, 0) + 1);
                    cols.put(j, cols.getOrDefault(j, 0) + 1);
                }
            }
        }
        int ans = 0;
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (grid[i][j] == 1 && (rows.get(i) > 1 || cols.get(j) > 1)) {
                    ++ans;
                }
            }
        }
        return ans;
    }
}

[sol1-C#]

public class Solution {
    public int CountServers(int[][] grid) {
        int m = grid.Length, n = grid[0].Length;
        IDictionary<int, int> rows = new Dictionary<int, int>();
        IDictionary<int, int> cols = new Dictionary<int, int>();
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (grid[i][j] == 1) {
                    rows.TryAdd(i, 0);
                    ++rows[i];
                    cols.TryAdd(j, 0);
                    ++cols[j];
                }
            }
        }
        int ans = 0;
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (grid[i][j] == 1 && (rows[i] > 1 || cols[j] > 1)) {
                    ++ans;
                }
            }
        }
        return ans;
    }
}

[sol1-Python3]

class Solution:
    def countServers(self, grid: List[List[int]]) -> int:
        m, n = len(grid), len(grid[0])
        rows, cols = Counter(), Counter()
        for i in range(m):
            for j in range(n):
                if grid[i][j] == 1:
                    rows[i] += 1
                    cols[j] += 1
        
        ans = 0
        for i in range(m):
            for j in range(n):
                if grid[i][j] == 1 and (rows[i] > 1 or cols[j] > 1):
                    ans += 1
        
        return ans

[sol1-C]

int countServers(int** grid, int gridSize, int* gridColSize) {
    int m = gridSize, n = gridColSize[0];
    int rows[m], cols[n];
    memset(rows, 0, sizeof(rows));
    memset(cols, 0, sizeof(cols));
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j) {
            if (grid[i][j] == 1) {
                ++rows[i];
                ++cols[j];
            }
        }
    }
    int ans = 0;
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j) {
            if (grid[i][j] == 1 && (rows[i] > 1 || cols[j] > 1)) {
                ++ans;
            }
        }
    }
    return ans;
}

[sol1-Go]

func countServers(grid [][]int) int {
    m := len(grid)
    n := len(grid[0])
    rows := make(map[int]int)
    cols := make(map[int]int)
    for i := 0; i < m; i++ {
        for j := 0; j < n; j++ {
            if grid[i][j] == 1 {
                rows[i] = rows[i] + 1
                cols[j] = cols[j] + 1
            }
        }
    }
    ans := 0
    for i := 0; i < m; i++ {
        for j := 0; j < n; j++ {
            if grid[i][j] == 1 && (rows[i] > 1 || cols[j] > 1) {
                ans++
            }
        }
    }
    return ans
}

[sol1-JavaScript]

var countServers = function(grid) {
    const m = grid.length, n = grid[0].length;
    const rows = new Map();
    const cols = new Map();
    for (let i = 0; i < m; ++i) {
        for (let j = 0; j < n; ++j) {
            if (grid[i][j] == 1) {
                rows.set(i, (rows.get(i) || 0) + 1);
                cols.set(j, (cols.get(j) || 0) + 1);
            }
        }
    }
    let ans = 0;
    for (let i = 0; i < m; ++i) {
        for (let j = 0; j < n; ++j) {
            if (grid[i][j] == 1 && ((rows.get(i) || 0) > 1 || (cols.get(j) || 0) > 1)) {
                ++ans;
            }
        }
    }
    return ans;
};

复杂度分析

• 时间复杂度：O(mn)。

• 空间复杂度：O(m+n)，即为哈希映射需要使用的空间。