Number of Ships in a Rectangle - Practice Coding Problems

Number of Ships in a Rectangle - Problem

Interactive Ship Detection Challenge

Imagine you're a naval commander using sonar to detect ships in a rectangular area of the ocean! 🚢 Each ship occupies exactly one integer coordinate point on a 2D grid, and no two ships can occupy the same position.

You have access to a special sonar function Sea.hasShips(topRight, bottomLeft) that can scan any rectangular region and tell you if there's at least one ship in that area (including the boundaries). Your mission: count the exact number of ships in a given rectangle.

⚠️ Critical Constraints:
• Maximum 10 ships in the target rectangle
• You can only call hasShips() up to 400 times
• Must use efficient divide-and-conquer strategy

🎯 Goal: Return the total count of ships in the specified rectangular region using minimal sonar calls.

Input & Output

example_1.py — Basic Case

$ Input: ships = [[1,1],[2,2],[3,3],[5,5]], topRight = [4,4], bottomLeft = [0,0]

› Output: 3

💡 Note: In the rectangle from [0,0] to [4,4], ships at [1,1], [2,2], and [3,3] are within bounds. Ship at [5,5] is outside the rectangle, so we count 3 ships total.

example_2.py — Edge Boundaries

$ Input: ships = [[0,0],[1,1],[2,2]], topRight = [2,2], bottomLeft = [0,0]

› Output: 3

💡 Note: All three ships are exactly on the boundary points of the rectangle. The hasShips function includes boundary points, so all ships are counted.

example_3.py — Empty Region

$ Input: ships = [[10,10],[15,15]], topRight = [5,5], bottomLeft = [0,0]

› Output: 0

💡 Note: No ships exist within the rectangle [0,0] to [5,5]. The hasShips call returns false immediately, and we return 0 without further subdivision.

Visualization

Tap to expand

Understanding the Visualization

Wide Area Scan

First sonar ping covers the entire search rectangle

Quadrant Division

If ships detected, divide into 4 smaller regions

Selective Scanning

Only ping quadrants that showed positive results

Pinpoint Location

Continue until each ship is isolated to a single coordinate

Key Takeaway

🎯 Key Insight: Only search regions that actually contain ships - empty ocean areas can be completely ignored, reducing API calls by 90%+

Time & Space Complexity

Time Complexity

⏱️

O(S × log(A))

Where S is number of ships (≤10) and A is rectangle area. Each ship requires log(A) calls to locate

⚡ Linearithmic

Space Complexity

O(log(A))

Recursion depth is logarithmic in the rectangle area

✓ Linear Space

Constraints

1 ≤ ships.length ≤ 10
ships[i].length == 2
bottomLeft.length == topRight.length == 2
0 ≤ bottomLeft[0] ≤ topRight[0] ≤ 1000
0 ≤ bottomLeft[1] ≤ topRight[1] ≤ 1000
At most 400 calls to hasShips are allowed
ships[i] are unique coordinates
At most 10 ships in the given rectangle

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses divide and conquer with early pruning. First check if a region contains ships - if not, skip it entirely. If yes, recursively divide into quadrants and search only non-empty ones. This reduces API calls from O(W×H) to O(S×log(A)) where S≤10 ships.

Common Approaches

Approach	Time	Space	Notes
✓ Divide and Conquer (Optimal)	O(S × log(A))	O(log(A))	Recursively divide regions that contain ships into smaller quadrants
Brute Force (Check Every Point)	O(W × H)	O(1)	Check each coordinate point individually

Divide and Conquer (Optimal) — Algorithm Steps

Check if current rectangle has any ships using hasShips()
If no ships, return 0 (prune this branch)
If single point with ships, return 1 (found a ship)
Otherwise, divide rectangle into 2 or 4 smaller regions
Recursively count ships in each non-empty sub-region
Sum up results from all sub-regions

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Check

Check if the entire rectangle contains any ships

Divide Region

Split rectangle into 4 quadrants around the midpoint

Recursive Search

Only search quadrants that contain ships, ignore empty ones

Base Case

When region is a single point with a ship, count it

Code -

solution.c — C

// Optimal Divide and Conquer Solution
int countShips(Sea* sea, int topRight[2], int bottomLeft[2]) {
    // Base case: if no ships in this region
    if (!hasShips(sea, topRight, bottomLeft)) {
        return 0;
    }
    
    // Base case: single point with ship
    if (topRight[0] == bottomLeft[0] && topRight[1] == bottomLeft[1]) {
        return 1;
    }
    
    // Divide rectangle into smaller regions
    int midX = (topRight[0] + bottomLeft[0]) / 2;
    int midY = (topRight[1] + bottomLeft[1]) / 2;
    
    int count = 0;
    
    // Check bottom-left quadrant
    int tr1[2] = {midX, midY};
    count += countShips(sea, tr1, bottomLeft);
    
    // Check bottom-right quadrant
    if (midX + 1 <= topRight[0]) {
        int tr2[2] = {topRight[0], midY};
        int bl2[2] = {midX + 1, bottomLeft[1]};
        count += countShips(sea, tr2, bl2);
    }
    
    // Check top-left quadrant
    if (midY + 1 <= topRight[1]) {
        int tr3[2] = {midX, topRight[1]};
        int bl3[2] = {bottomLeft[0], midY + 1};
        count += countShips(sea, tr3, bl3);
    }
    
    // Check top-right quadrant
    if (midX + 1 <= topRight[0] && midY + 1 <= topRight[1]) {
        int bl4[2] = {midX + 1, midY + 1};
        count += countShips(sea, topRight, bl4);
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(S × log(A))

Where S is number of ships (≤10) and A is rectangle area. Each ship requires log(A) calls to locate

⚡ Linearithmic

Space Complexity

O(log(A))

Recursion depth is logarithmic in the rectangle area

✓ Linear Space

Constraints

1 ≤ ships.length ≤ 10
ships[i].length == 2
bottomLeft.length == topRight.length == 2
0 ≤ bottomLeft[0] ≤ topRight[0] ≤ 1000
0 ≤ bottomLeft[1] ≤ topRight[1] ≤ 1000
At most 400 calls to hasShips are allowed
ships[i] are unique coordinates
At most 10 ships in the given rectangle

28.9K Views

Medium Frequency

~25 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Divide and Conquer (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler