Count Servers that Communicate

Count Servers that Communicate - Problem

You are given a map of a server center, represented as a m × n integer matrix grid, where 1 means that on that cell there is a server and 0 means that there is no server.

Two servers are said to communicate if they are on the same row or on the same column.

Return the number of servers that communicate with any other server.

Input & Output

Example 1 — Basic Case

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

› Output: 0

💡 Note: No server can communicate with any other server. Server at (0,0) has no other server in row 0 or column 0. Server at (1,1) has no other server in row 1 or column 1.

Example 2 — Same Row Communication

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

› Output: 3

💡 Note: Server (1,0) and (1,1) can communicate (same row). Server (0,0) and (1,0) can communicate (same column). All 3 servers can communicate.

Example 3 — Mixed Communication

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

› Output: 4

💡 Note: Servers (0,0) and (0,1) communicate via same row. Servers (1,2) and (2,2) communicate via same column. Server (3,3) is isolated. Total: 4 servers communicate.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8 M Microsoft 6

The key insight is that a server can communicate if and only if there's at least one other server in its row or column. Best approach uses two-pass counting: first pass counts servers per row/column, second pass identifies communicating servers. Time: O(mn), Space: O(m + n)

Common Approaches

✓ Brute Force

⏱️ Time: O(m²n²) Space: O(1)

Iterate through each cell containing a server, then check all other cells to find if any server exists in the same row or column. If found, increment the count.

Two-Pass Count

⏱️ Time: O(mn) Space: O(m + n)

Use two arrays to count servers in each row and column. Then scan the grid once more, counting servers that are in rows or columns with more than one server.

Brute Force — Algorithm Steps

Find all server positions
For each server, scan entire grid for servers in same row/column
Count servers that have at least one communication partner

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Server

Locate a server at position (i,j)

Check All

Scan entire row and column for other servers

Count

If communication found, increment counter

Code -

solution.c — C

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

int solution(int** grid, int gridSize, int* gridColSize) {
    if (gridSize == 0 || gridColSize[0] == 0) return 0;
    
    int count = 0;
    
    for (int i = 0; i < gridSize; i++) {
        for (int j = 0; j < gridColSize[i]; j++) {
            if (grid[i][j] == 1) {
                int canCommunicate = 0;
                
                // Check same row
                for (int k = 0; k < gridColSize[i]; 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 < gridSize; k++) {
                        if (k != i && grid[k][j] == 1) {
                            canCommunicate = 1;
                            break;
                        }
                    }
                }
                
                if (canCommunicate) count++;
            }
        }
    }
    
    return count;
}

int parseGrid(char* input, int*** grid, int** gridColSize) {
    // Simple JSON array parser for 2D arrays
    int rows = 0;
    char* p = input;
    
    // Count rows by counting '[' after the first one
    while (*p) {
        if (*p == '[' && p > input) rows++;
        p++;
    }
    
    if (rows == 0) return 0;
    
    *grid = (int**)malloc(rows * sizeof(int*));
    *gridColSize = (int*)malloc(rows * sizeof(int));
    
    p = input + 1; // Skip first '['
    for (int i = 0; i < rows; i++) {
        // Skip to start of row
        while (*p == '[' || *p == ',' || *p == ' ') p++;
        
        // Count numbers in this row
        char* rowStart = p;
        int cols = 0;
        while (*p && *p != ']') {
            if (*p == ',' || (*p >= '0' && *p <= '9')) {
                if (*p != ',') cols++;
                while (*p >= '0' && *p <= '9') p++;
                while (*p == ',' || *p == ' ') p++;
            } else {
                p++;
            }
        }
        if (cols == 0) cols = 1; // Single element
        
        (*gridColSize)[i] = cols;
        (*grid)[i] = (int*)malloc(cols * sizeof(int));
        
        // Parse numbers
        p = rowStart;
        int j = 0;
        while (*p && *p != ']' && j < cols) {
            if (*p >= '0' && *p <= '9') {
                (*grid)[i][j++] = *p - '0';
            }
            p++;
        }
        
        // Skip to next row
        while (*p && *p != '[' && *p != ']') p++;
        if (*p == ']') p++;
    }
    
    return rows;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline
    input[strcspn(input, "\n")] = 0;
    
    int** grid;
    int* gridColSize;
    int gridSize = parseGrid(input, &grid, &gridColSize);
    
    int result = solution(grid, gridSize, gridColSize);
    printf("%d\n", result);
    
    // Cleanup
    for (int i = 0; i < gridSize; i++) {
        free(grid[i]);
    }
    free(grid);
    free(gridColSize);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

For each of mn cells, we potentially check all mn cells again

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables

⚡ Linearithmic Space

32.1K Views

Medium Frequency

~15 min Avg. Time

847 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler