<p>You are given a <strong>0-indexed</strong> 2D matrix <code>grid</code> of size <code>m x n</code>, where <code>(r, c)</code> represents:</p>

<ul>
	<li>A <strong>land</strong> cell if <code>grid[r][c] = 0</code>, or</li>
	<li>A <strong>water</strong> cell containing <code>grid[r][c]</code> fish, if <code>grid[r][c] &gt; 0</code>.</li>
</ul>

<p>A fisher can start at any <strong>water</strong> cell <code>(r, c)</code> and can do the following operations any number of times:</p>

<ul>
	<li>Catch all the fish at cell <code>(r, c)</code>, or</li>
	<li>Move to any adjacent <strong>water</strong> cell.</li>
</ul>

<p>Return <em>the <strong>maximum</strong> number of fish the fisher can catch if he chooses his starting cell optimally, or </em><code>0</code> if no water cell exists.</p>

<p>An <strong>adjacent</strong> cell of the cell <code>(r, c)</code>, is one of the cells <code>(r, c + 1)</code>, <code>(r, c - 1)</code>, <code>(r + 1, c)</code> or <code>(r - 1, c)</code> if it exists.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2023/03/29/example.png" style="width: 241px; height: 161px;" />
<pre>
<strong>Input:</strong> grid = [[0,2,1,0],[4,0,0,3],[1,0,0,4],[0,3,2,0]]
<strong>Output:</strong> 7
<strong>Explanation:</strong> The fisher can start at cell <code>(1,3)</code> and collect 3 fish, then move to cell <code>(2,3)</code>&nbsp;and collect 4 fish.
</pre>

<p><strong class="example">Example 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2023/03/29/example2.png" />
<pre>
<strong>Input:</strong> grid = [[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,1]]
<strong>Output:</strong> 1
<strong>Explanation:</strong> The fisher can start at cells (0,0) or (3,3) and collect a single fish. 
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>m == grid.length</code></li>
	<li><code>n == grid[i].length</code></li>
	<li><code>1 &lt;= m, n &lt;= 10</code></li>
	<li><code>0 &lt;= grid[i][j] &lt;= 10</code></li>
</ul>

class DSU:

    def __init__(self, n, values):
        self.values = values
        self.parent = list(range(n))
        self.rank = [1] * n

    def _parent(self, u):
        if self.parent[u] == u:
            return u
        self.parent[u] = self._parent(self.parent[u])
        return self.parent[u]

    def unite(self, u, v):
        parent_u = self._parent(u)
        parent_v = self._parent(v)
        if parent_u != parent_v:
            if self.rank[parent_u] < self.rank[parent_v]:
                parent_u, parent_v = parent_v, parent_u
            self.parent[parent_v] = parent_u
            self.rank[parent_u] += self.rank[parent_v]
            self.values[parent_u] += self.values[parent_v]
        return self.values[parent_u]


class Solution:
    def findMaxFish(self, grid: List[List[int]]) -> int:
        values = []
        for row in grid:
            values.extend(row)
        dsu = DSU(len(values), values)
        max_value = 0
        for row_index in range(len(grid)):
            for column_index in range(len(grid[0])):
                if not grid[row_index][column_index]:
                    continue
                max_value = max(max_value, grid[row_index][column_index])
                current_index = row_index * len(grid[0]) + column_index
                if row_index > 0 and grid[row_index - 1][column_index]:
                    max_value = max(max_value, dsu.unite(current_index, current_index - len(grid[0])))
                if column_index > 0 and grid[row_index][column_index - 1]:
                    max_value = max(max_value, dsu.unite(current_index, current_index - 1))
        return max_value
148