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

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

✓ Binary Search Answer

⏱️ Time: N/A Space: N/A

Prefix Sum

⏱️ Time: N/A Space: N/A

DFS/BFS for Each Connected Component (Optimal)

⏱️ Time: O(mn) Space: O(mn)

Instead of trying every starting cell, we traverse the grid once and explore each connected water component only when we encounter it for the first time. This eliminates all redundant work.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int grid[15][15];
static bool visited[15][15];
static int m, n;
static int dx[4] = {-1, 1, 0, 0};
static int dy[4] = {0, 0, -1, 1};

int dfs(int x, int y) {
    if (x < 0 || x >= m || y < 0 || y >= n || visited[x][y] || grid[x][y] == 0) {
        return 0;
    }
    
    visited[x][y] = true;
    int fish = grid[x][y];
    
    for (int i = 0; i < 4; i++) {
        int nx = x + dx[i];
        int ny = y + dy[i];
        fish += dfs(nx, ny);
    }
    
    return fish;
}

int solution() {
    // Reset visited array
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            visited[i][j] = false;
        }
    }
    
    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 fish = dfs(i, j);
                if (fish > maxFish) {
                    maxFish = fish;
                }
            }
        }
    }
    
    return maxFish;
}

int main() {
    char line[10000];
    if (!fgets(line, sizeof(line), stdin)) {
        printf("0\n");
        return 0;
    }
    
    // Remove newline
    line[strcspn(line, "\n")] = 0;
    
    // Handle empty array case
    if (strcmp(line, "[]") == 0) {
        printf("0\n");
        return 0;
    }
    
    // Parse the matrix
    // Format: [[0,2,1,0],[4,0,0,3],[1,0,0,4],[0,3,2,0]]
    
    // Count rows by counting '],'
    m = 1;
    for (int i = 0; line[i]; i++) {
        if (line[i] == ']' && line[i+1] == ',' && line[i+2] == '[') {
            m++;
        }
    }
    
    // Count columns in first row
    n = 1;
    int i = 2; // Skip [[
    while (line[i] != ']') {
        if (line[i] == ',') n++;
        i++;
    }
    
    // Parse values using manual parsing to avoid strtok issues
    int row = 0, col = 0;
    int num = 0;
    bool inNumber = false;
    
    for (i = 0; line[i]; i++) {
        if (line[i] >= '0' && line[i] <= '9') {
            if (!inNumber) {
                num = 0;
                inNumber = true;
            }
            num = num * 10 + (line[i] - '0');
        } else {
            if (inNumber) {
                grid[row][col] = num;
                col++;
                if (col == n) {
                    col = 0;
                    row++;
                }
                inNumber = false;
            }
        }
    }
    
    // Handle last number if line doesn't end with delimiter
    if (inNumber) {
        grid[row][col] = num;
    }
    
    printf("%d\n", solution());
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ 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