Codestin Search App

Battleships in a Board - Problem

Naval Battle Grid Scanner

You are a naval intelligence officer analyzing enemy positions on a battle grid. Given an m x n matrix representing the ocean battlefield, your mission is to count the total number of enemy battleships deployed.

The grid uses the following symbols:
• 'X' - Part of a battleship
• '.' - Empty water

Battleship Rules:
1. Battleships can only be placed horizontally or vertically
2. Each battleship forms either a 1 × k (horizontal) or k × 1 (vertical) shape
3. Battleships are never adjacent - they're separated by at least one cell of water
4. A single 'X' cell also counts as a battleship of size 1

Your task is to return the total count of individual battleships on the board.

Example:
[["X",".",".","X"],[".",".",".","X"],[".",".",".","X"]]
This represents 2 battleships: one single cell and one vertical 3-cell battleship.

Input & Output

example_1.py — Multiple Battleships

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

› Output: 2

💡 Note: The first battleship is a single cell at (0,0). The second battleship is a vertical 3-cell ship occupying (0,3), (1,3), and (2,3). Total count: 2 battleships.

example_2.py — Single Cell Battleships

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

› Output: 1

💡 Note: A single 'X' cell represents one battleship of size 1x1.

example_3.py — Horizontal and Vertical Ships

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

› Output: 2

💡 Note: One horizontal 2-cell battleship at (0,0)-(0,1) and one vertical 2-cell battleship at (0,3)-(1,3). The empty space ensures proper separation.

Constraints

m == board.length
n == board[i].length
1 ≤ m, n ≤ 200
board[i][j] is either '.' or 'X'
Follow up: Could you do it in one-pass, using only O(1) extra memory and without modifying the values board?

Visualization

Tap to expand

Understanding the Visualization

Radar Sweep

Scan the ocean grid systematically from top-left to bottom-right

Ship Detection

When radar detects a ship part ('X'), check if it's the ship's origin point

Origin Verification

A point is an origin if no ship parts exist above it or to its left

Count Ships

Each origin point represents exactly one distinct battleship

Key Takeaway

🎯 Key Insight: Every battleship has exactly one top-left corner. By counting only these origin points, we achieve optimal efficiency while maintaining perfect accuracy in our naval reconnaissance mission!

Asked in

a Amazon 45 ⊞ Microsoft 32 G Google 28 f Meta 15

The optimal solution uses top-left corner detection - counting only 'X' cells that have no 'X' above or to their left. This elegant approach achieves O(1) space complexity and requires only a single pass through the matrix, leveraging the key insight that every battleship has exactly one top-left corner.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force DFS	O(m×n)	O(m×n)	Use DFS to explore each battleship completely when found
Top-Left Corner Detection (Optimal)	O(m×n)	O(1)	Count only 'X' cells that are the top-left corner of their battleship

Brute Force DFS — Algorithm Steps

Iterate through every cell in the matrix
When an unvisited 'X' is found, increment battleship counter
Use DFS to mark all connected 'X' cells as visited
Continue until all cells are processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Scan

Begin scanning grid from top-left

Find 'X'

When 'X' found, increment count and start DFS

DFS Exploration

Mark all connected 'X' cells as visited

Continue Scan

Resume scanning for next unvisited battleship

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.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 countBattleships(char** board, int boardSize, int* boardColSize) {
    if (boardSize == 0 || boardColSize[0] == 0) return 0;
    
    int m = boardSize, n = boardColSize[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]) {
                count++;
                dfs(board, visited, i, j, m, n);
            }
        }
    }
    
    for (int i = 0; i < m; i++) {
        free(visited[i]);
    }
    free(visited);
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Each cell is visited at most twice - once in main loop, once in DFS

✓ Linear Growth

Space Complexity

O(m×n)

Visited matrix plus recursion stack in worst case

⚡ Linearithmic Space

89.5K Views

Medium Frequency

~15 min Avg. Time

1.9K 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 DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler