Leetcode | Maximum Number of Fish in a Grid | Kotlin

devstromo · devstromo · commit 5ad7a0817379 · 2025-04-06T20:13:16.000-03:00
diff --git a/leetcode/src/main/kotlin/com/devstromo/medium/p2658/DESCRIPTION.md b/leetcode/src/main/kotlin/com/devstromo/medium/p2658/DESCRIPTION.md
@@ -0,0 +1,35 @@
+# 2658. Maximum Number of Fish in a Grid
+
+You are given a 0-indexed 2D matrix `grid` of size `m x n`, where `(r, c)` represents:
+
+- A land cell if `grid[r][c] = 0`, or
+- A water cell containing `grid[r][c]` fish, if `grid[r][c] > 0`.
+
+A fisher can start at any water cell `(r, c)` and can do the following operations any number of times:
+
+- Catch all the fish at cell `(r, c)`, or
+- Move to any adjacent water cell.
+
+Return the maximum number of fish the fisher can catch if he chooses his starting cell optimally, or 0 if no water cell
+exists.
+
+An adjacent cell of the cell `(r, c)`, is one of the cells `(r, c + 1)`, `(r, c - 1)`, `(r + 1, c)` or `(r - 1, c)` if it exists.
+
+Example 1:
+
+Input: grid = [[0,2,1,0],[4,0,0,3],[1,0,0,4],[0,3,2,0]]
+Output: 7
+Explanation: The fisher can start at cell (1,3) and collect 3 fish, then move to cell (2,3) and collect 4 fish.
+
+Example 2:
+
+Input: grid = [[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,1]]
+Output: 1
+Explanation: The fisher can start at cells (0,0) or (3,3) and collect a single fish.
+
+Constraints:
+
+- `m == grid.length`
+- `n == grid[i].length`
+- `1 <= m, n <= 10`
+- `0 <= grid[i][j] <= 10`
diff --git a/leetcode/src/main/kotlin/com/devstromo/medium/p2658/SolutionKt.kt b/leetcode/src/main/kotlin/com/devstromo/medium/p2658/SolutionKt.kt
@@ -0,0 +1,27 @@
+package com.devstromo.medium.p2658
+
+class SolutionKt {
+    fun findMaxFish(grid: Array<IntArray>): Int {
+        var max = 0
+        for (i in grid.indices) {
+            for (j in grid[0].indices) {
+                if (grid[i][j] != 0) {
+                    max = maxOf(max, explore(i, j, grid))
+                }
+            }
+        }
+        return max
+    }
+
+    private fun explore(row: Int, col: Int, grid: Array<IntArray>): Int {
+        if (row < 0 || col < 0 || row >= grid.size || col >= grid[0].size) return 0
+        if (grid[row][col] == 0) return 0
+        var total = grid[row][col]
+        grid[row][col] = 0
+        total += explore(row, col + 1, grid) +
+                explore(row, col - 1, grid) +
+                explore(row + 1, col, grid) +
+                explore(row - 1, col, grid)
+        return total
+    }
+}
diff --git a/leetcode/src/test/kotlin/com/devstromo/medium/p2658/SolutionKtUnitTest.kt b/leetcode/src/test/kotlin/com/devstromo/medium/p2658/SolutionKtUnitTest.kt
@@ -0,0 +1,33 @@
+package com.devstromo.medium.p2658
+
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+class SolutionKtUnitTest {
+    private val solution = SolutionKt()
+
+    @Test
+    fun `Test Maximum Number of Fish in a Grid`() {
+        assertEquals(
+            7, solution.findMaxFish(
+                arrayOf(
+                    intArrayOf(0, 2, 1, 0),
+                    intArrayOf(4, 0, 0, 3),
+                    intArrayOf(1, 0, 0, 4),
+                    intArrayOf(0, 3, 2, 0)
+                )
+            )
+        )
+
+        assertEquals(
+            1, solution.findMaxFish(
+                arrayOf(
+                    intArrayOf(1, 0, 0, 0),
+                    intArrayOf(0, 0, 0, 0),
+                    intArrayOf(0, 0, 0, 0),
+                    intArrayOf(0, 0, 0, 1)
+                )
+            )
+        )
+    }
+}
