> For the complete documentation index, see [llms.txt](https://www.pranaypourkar.co.in/the-programmers-guide/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://www.pranaypourkar.co.in/the-programmers-guide/algorithm/tree/problems-set-1.md).

# Problems - Set 1

## Easy

## Medium

### Pond Sizes

We are given a **2D grid of integers** that represents a plot of land. Each cell in the grid has a number:

* If the number is `0`, it means **water**.
* Any number greater than `0` means **land**, with the value representing the height above sea level.

**Find all the ponds** in the matrix and return their **sizes**.

A **pond** is a group of water cells (`0`s) that are **connected** to each other. Two water cells are considered **connected** if they touch **vertically**, **horizontally**, or **diagonally**.

For each such group (pond), we want to know how many `0`s are in that group — that's the **size** of the pond.

A 2D array like this:

```
0 2 1 0
0 1 0 1
1 1 0 1
0 1 0 1
```

A list of integers representing the sizes of the ponds.\
For the input above, the expected result is:

```
[2, 1, 4]
```

Let's mark all water (`0`) cells and group them if they are connected:

There are **three ponds**:

1. **Pond A**: top-left corner `0`s → size 2
2. **Pond B**: single `0` at top-right corner → size 1
3. **Pond C**: group of 4 `0`s in the center-bottom → size 4

We can solve the **Pond Sizes** problem using **Depth-First Search (DFS)** or **Breadth-First Search (BFS)** to find all connected `0`s in the matrix, including diagonally. Each group of connected water cells is considered a pond, and we compute the size (number of cells) of each.

```java
import java.util.*;

public class PondSizes {

    public static List<Integer> computePondSizes(int[][] land) {
        List<Integer> pondSizes = new ArrayList<>();
        int rows = land.length;
        int cols = land[0].length;
        boolean[][] visited = new boolean[rows][cols];

        for (int r = 0; r < rows; r++) {
            for (int c = 0; c < cols; c++) {
                if (land[r][c] == 0 && !visited[r][c]) {
                    int size = dfs(land, visited, r, c);
                    pondSizes.add(size);
                }
            }
        }

        return pondSizes;
    }

    private static int dfs(int[][] land, boolean[][] visited, int r, int c) {
        if (r < 0 || c < 0 || r >= land.length || c >= land[0].length) return 0;
        if (land[r][c] != 0 || visited[r][c]) return 0;

        visited[r][c] = true;
        int size = 1;

        // 8 directions: vertical, horizontal, diagonal
        int[] dx = {-1, -1, -1, 0, 0, 1, 1, 1};
        int[] dy = {-1, 0, 1, -1, 1, -1, 0, 1};

        for (int d = 0; d < 8; d++) {
            size += dfs(land, visited, r + dx[d], c + dy[d]);
        }

        return size;
    }

    public static void main(String[] args) {
        int[][] land = {
            {0, 2, 1, 0},
            {0, 1, 0, 1},
            {1, 1, 0, 1},
            {0, 1, 0, 1}
        };

        List<Integer> result = computePondSizes(land);
        Collections.sort(result); // optional, for ordered output
        System.out.println("Pond sizes: " + result);  // Expected: [1, 2, 4]
    }
}
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://www.pranaypourkar.co.in/the-programmers-guide/algorithm/tree/problems-set-1.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.