Maximum Number of Fish in a Grid - Practice Coding Problems

Maximum Number of Fish in a Grid - Problem

Imagine you're a fisher exploring a vast archipelago represented by a 2D grid! Each cell in this grid can be either:

0 - A land cell where you cannot go
positive integer - A water cell containing that many fish

As an expert fisher, you can:

🎣 Catch all fish in your current water cell
🚤 Move to adjacent water cells (up, down, left, right)

Your mission: Choose the optimal starting position to maximize your total catch! You can only move between connected water cells, so choose wisely.

Goal: Return the maximum number of fish you can catch, or 0 if there are no water cells.

Input & Output

example_1.py — Basic Connected Water

$ Input: grid = [[0,2,1,0],[4,0,0,3],[1,0,0,4],[0,3,2,0]]

› Output: 7

💡 Note: The fisher can start at (1,0) and catch 4 fish, then move to (2,0) and catch 1 fish, then move to (3,1) and catch 3 fish. However, they cannot reach (3,2) or other water cells from this position. The optimal path gives 4+1 = 5 fish from the left component, but there's a larger component with 7 fish total.

example_2.py — Single Large Component

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

› Output: 6

💡 Note: Starting from any cell in the connected water region (containing values 1,2,3), the fisher can catch all fish in this component for a total of 1+2+3 = 6 fish.

example_3.py — No Water Cells

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

› Output: 0

💡 Note: There are no water cells (all cells have value 0), so the fisher cannot catch any fish.

Constraints

m == grid.length
n == grid[i].length
1 <= m, n <= 10
0 <= grid[i][j] <= 10

Visualization

Tap to expand

Understanding the Visualization

Survey the Waters

Look at the grid to identify all water cells (positive values) and land cells (zeros)

Find Island Chains

Each connected group of water cells forms a separate island chain

Explore Each Chain

Use DFS/BFS to fully explore each connected water region once

Choose Best Chain

Return the total fish from the richest island chain

Key Takeaway

🎯 Key Insight: Instead of trying every starting position, we identify connected components once and find the richest one. This reduces time complexity from O(m²n²) to O(mn)!

Asked in

a Amazon 25 ⊞ Microsoft 18 G Google 15 f Meta 12

This is a classic connected components problem. Use DFS or BFS to explore each connected water region exactly once, calculating the total fish in each component. The optimal approach achieves O(mn) time complexity by visiting each cell only once, compared to the brute force O(m²n²) approach that redundantly explores the same regions multiple times.

Common Approaches

Approach	Time	Space	Notes
✓ DFS/BFS for Each Connected Component (Optimal)	O(mn)	O(mn)	Find each connected component once using DFS/BFS, avoiding redundant exploration

DFS/BFS for Each Connected Component (Optimal) — Algorithm Steps

Iterate through each cell in the grid
When we find an unvisited water cell, start DFS/BFS
Explore the entire connected component and sum fish
Mark all cells in this component as visited permanently
Continue searching for other unvisited components
Return the maximum sum found among all components

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan Grid

Iterate through grid looking for unvisited water cells

Found Component

When we find one, start DFS to explore entire component

Mark Visited

Mark all cells in component as permanently visited

Continue Scanning

Continue scanning for other components

Code -

solution.c — C

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

int dfs(int** grid, int r, int c, int m, int n, bool** visited) {
    if (r < 0 || r >= m || c < 0 || c >= n || grid[r][c] == 0 || visited[r][c]) {
        return 0;
    }
    
    visited[r][c] = true;
    int total = grid[r][c];
    
    int directions[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    for (int i = 0; i < 4; i++) {
        total += dfs(grid, r + directions[i][0], c + directions[i][1], m, n, visited);
    }
    
    return total;
}

int findMaxFish(int** grid, int gridSize, int* gridColSize) {
    if (gridSize == 0 || gridColSize[0] == 0) {
        return 0;
    }
    
    int m = gridSize, n = gridColSize[0];
    bool** visited = malloc(m * sizeof(bool*));
    for (int i = 0; i < m; i++) {
        visited[i] = calloc(n, sizeof(bool));
    }
    
    int maxFish = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] > 0 && !visited[i][j]) {
                int fishCount = dfs(grid, i, j, m, n, visited);
                if (fishCount > maxFish) {
                    maxFish = fishCount;
                }
            }
        }
    }
    
    for (int i = 0; i < m; i++) {
        free(visited[i]);
    }
    free(visited);
    
    return maxFish;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(mn)

Each cell is visited exactly once during the entire algorithm

✓ Linear Growth

Space Complexity

O(mn)

Space for visited array and recursion stack depth

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~15 min Avg. Time

892 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/BFS for Each Connected Component (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler