Battleships in a Board

Battleships in a Board - Problem

Given an m x n matrix board where each cell is a battleship 'X' or empty '.', return the number of battleships on the board.

Battleships can only be placed horizontally or vertically on the board. In other words, they can only be made of the shape 1 x k (1 row, k columns) or k x 1 (k rows, 1 column), where k can be of any size.

At least one horizontal or vertical cell separates between two battleships (i.e., there are no adjacent battleships).

Input & Output

Example 1 — Mixed Battleships

$ Input: board = [["X",".",".","X"],[".",...,".","X"],[".",...,".","X"]]

› Output: 2

💡 Note: First battleship is single cell at (0,0). Second battleship is vertical at positions (0,3), (1,3), (2,3). Total count is 2.

Example 2 — Single Ship

$ Input: board = [["X"]]

› Output: 1

💡 Note: Single cell battleship at position (0,0). Total count is 1.

Example 3 — No Ships

$ Input: board = [["."]]

› Output: 0

💡 Note: No battleship cells found in the grid. Total count is 0.

Constraints

m == board.length
n == board[i].length
1 ≤ m, n ≤ 200
board[i][j] is either '.' or 'X'

Visualization

Tap to expand

Asked in

M Microsoft 15 A Apple 12

The key insight is that we can count battleships by finding their top-left corners instead of exploring entire ships. Best approach is the Top-Left Corner Detection with optimal Time: O(m×n), Space: O(1).

Common Approaches

✓ DFS Exploration

⏱️ Time: O(m×n) Space: O(m×n)

For each unvisited 'X' cell, perform DFS to explore the entire battleship and mark all cells as visited. Count each complete battleship exploration as one ship.

Top-Left Corner Detection

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

Instead of exploring entire ships, count only when we find the top-left corner of each battleship. A cell is a top-left corner if it's 'X' and has no 'X' above or to the left.

DFS Exploration — Algorithm Steps

Iterate through each cell in the matrix
When finding an unvisited 'X', start DFS exploration
Mark all connected 'X' cells as visited during DFS
Increment battleship count for each DFS start

Visualization

Tap to expand

Step-by-Step Walkthrough

Find X

Locate first unvisited X cell

DFS Explore

Explore all connected X cells

Count Ship

Mark as visited and count one battleship

Code -

solution.c — C

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

void dfs(char** board, bool** visited, int i, int j, int m, int n) {
    if (i < 0 || i >= m || j < 0 || j >= n || visited[i][j] || board[i][j] == '.') {
        return;
    }
    
    visited[i][j] = true;
    dfs(board, visited, i+1, j, m, n);
    dfs(board, visited, i-1, j, m, n);
    dfs(board, visited, i, j+1, m, n);
    dfs(board, visited, i, j-1, m, n);
}

int solution(char** board, int m, int n) {
    if (m == 0 || n == 0) return 0;
    
    bool** visited = (bool**)malloc(m * sizeof(bool*));
    for (int i = 0; i < m; i++) {
        visited[i] = (bool*)calloc(n, sizeof(bool));
    }
    
    int count = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (board[i][j] == 'X' && !visited[i][j]) {
                dfs(board, visited, i, j, m, n);
                count++;
            }
        }
    }
    
    // Free memory
    for (int i = 0; i < m; i++) {
        free(visited[i]);
    }
    free(visited);
    
    return count;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    char grid[200][200];
    int m = 0, n = 0;
    int col = 0;
    int depth = 0;
    char* ptr = line;
    
    while (*ptr) {
        if (*ptr == '[') {
            depth++;
            if (depth == 2) col = 0;
        } else if (*ptr == ']') {
            if (depth == 2) {
                if (m == 0) n = col;
                m++;
            }
            depth--;
        } else if (*ptr == '"') {
            ptr++;
            if (*ptr == 'X' || *ptr == '.') {
                grid[m][col] = *ptr;
                col++;
            }
            ptr++;
        }
        ptr++;
    }
    
    char** board = (char**)malloc(m * sizeof(char*));
    for (int i = 0; i < m; i++) {
        board[i] = grid[i];
    }
    
    printf("%d\n", solution(board, m, n));
    
    free(board);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Visit each cell once, DFS explores each X cell exactly once

✓ Linear Growth

Space Complexity

O(m×n)

Visited matrix to track explored cells

✓ Linear Space

85.0K 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

DFS Exploration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler