Count Servers that Communicate - Practice Coding Problems

Count Servers that Communicate - Problem

Imagine you're managing a data center network where servers need to communicate with each other. You have a rectangular grid representing the server room layout, where 1 indicates a server is present and 0 means the position is empty.

Servers can communicate if they are in the same row or same column. A server that can communicate with at least one other server is considered "active in the network".

Goal: Count how many servers are actively participating in network communication.

Example: In a 2×3 grid [[1,0,1],[1,0,1]], all 4 servers can communicate (servers in same rows/columns), so the answer is 4.

Input & Output

example_1.py — Basic Grid

$ Input: grid = [[1,0],[0,1]]

› Output: 0

💡 Note: No server can communicate. Each server is alone in its row and column.

example_2.py — Multiple Communications

$ Input: grid = [[1,0,1],[1,0,1]]

› Output: 4

💡 Note: All 4 servers communicate. Row 0 has 2 servers, row 1 has 2 servers, columns 0&2 each have 2 servers.

example_3.py — Single Server

$ Input: grid = [[1]]

› Output: 0

💡 Note: Only one server exists, so it cannot communicate with anyone.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Scan Network

Count active servers on each network segment (row/column)

Identify Clusters

Servers on segments with 2+ servers can communicate

Count Active

Sum up all servers that are part of communication clusters

Key Takeaway

🎯 Key Insight: A server communicates if its row OR column has multiple servers - no need to check individual connections!

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 28 f Meta 22

The optimal solution uses a two-pass counting approach: first count servers in each row and column, then count servers where either row_count > 1 or col_count > 1. Time complexity: O(mn), Space: O(m+n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Each Server Against All Others)	O(m²n²)	O(1)	For each server, check if any other server exists in the same row or column
Two-Pass Counting (Optimal)	O(mn)	O(m+n)	First pass counts servers per row/column, second pass counts communicating servers

Brute Force (Check Each Server Against All Others) — Algorithm Steps

Iterate through each cell in the grid
For each server (cell with value 1), check all other cells
Count servers in the same row and same column
If total count > 1, this server can communicate
Increment the result counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Server

Pick a server to analyze

Check Row

Scan entire row for other servers

Check Column

Scan entire column for other servers

Count or Skip

Add to count if communication found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int countServers(int** grid, int gridSize, int* gridColSize) {
    if (gridSize == 0 || gridColSize[0] == 0) return 0;
    
    int rows = gridSize, cols = gridColSize[0];
    int count = 0;
    
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (grid[i][j] == 1) {
                int canCommunicate = 0;
                
                // Check same row
                for (int k = 0; k < cols; k++) {
                    if (k != j && grid[i][k] == 1) {
                        canCommunicate = 1;
                        break;
                    }
                }
                
                // Check same column if not already found
                if (!canCommunicate) {
                    for (int k = 0; k < rows; k++) {
                        if (k != i && grid[k][j] == 1) {
                            canCommunicate = 1;
                            break;
                        }
                    }
                }
                
                if (canCommunicate) count++;
            }
        }
    }
    
    return count;
}

int main() {
    // Example usage
    int grid[2][2] = {{1,0},{0,1}};
    int* gridPtr[2] = {grid[0], grid[1]};
    int colSizes[2] = {2, 2};
    printf("%d\n", countServers(gridPtr, 2, colSizes));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

For each of the m×n cells, we potentially check all m×n cells again

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, no additional data structures

✓ Linear Space

42.3K Views

Medium Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check Each Server Against All Others) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler