Pacific Atlantic Water Flow

Pacific Atlantic Water Flow - Problem

There is an m x n rectangular island that borders both the Pacific Ocean and Atlantic Ocean. The Pacific Ocean touches the island's left and top edges, and the Atlantic Ocean touches the island's right and bottom edges.

The island is partitioned into a grid of square cells. You are given an m x n integer matrix heights where heights[r][c] represents the height above sea level of the cell at coordinate (r, c).

The island receives a lot of rain, and the rain water can flow to neighboring cells directly north, south, east, and west if the neighboring cell's height is less than or equal to the current cell's height. Water can flow from any cell adjacent to an ocean into the ocean.

Return a 2D list of grid coordinates result where result[i] = [ri, ci] denotes that rain water can flow from cell (ri, ci) to both the Pacific and Atlantic oceans.

Input & Output

Example 1 — Basic Island Grid

$ Input: heights = [[1,2,2,3,5],[3,2,3,4,4],[2,4,5,3,1],[6,7,1,4,5],[5,1,1,2,4]]

› Output: [[0,4],[1,3],[1,4],[2,2],[3,0],[3,1],[4,0]]

💡 Note: These cells can flow water to both Pacific (top/left edges) and Atlantic (bottom/right edges). For example, cell (0,4) with height 5 can flow to Pacific through the top edge and to Atlantic through the right edge.

Example 2 — Simple Small Grid

$ Input: heights = [[1,2,3],[4,5,6],[7,8,9]]

› Output: [[0,2],[1,2],[2,0],[2,1],[2,2]]

💡 Note: Water flows from higher to lower or equal heights. Cell (0,2) can reach Pacific via top edge and Atlantic via right edge. Cell (2,0) can reach Pacific via left edge and Atlantic via bottom edge.

Example 3 — Single Cell

$ Input: heights = [[1]]

› Output: [[0,0]]

💡 Note: A single cell borders both oceans (touches all edges), so water can flow to both Pacific and Atlantic oceans.

Constraints

m == heights.length
n == heights[r].length
1 ≤ m, n ≤ 200
0 ≤ heights[r][c] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 32 a Amazon 28 M Microsoft 15 f Facebook 12

The key insight is to reverse the problem: instead of checking if each cell can reach both oceans, start from the ocean boundaries and find all cells that can be reached. Use reverse DFS from Pacific edges (top/left) and Atlantic edges (bottom/right), then find their intersection. Time: O(mn), Space: O(mn)

Common Approaches

✓ Brute Force DFS from Each Cell

⏱️ Time: O(m²n²) Space: O(mn)

Start from every cell and perform DFS in all directions where height decreases or stays same. Check if we can reach Pacific (top/left edges) and Atlantic (bottom/right edges) from that cell.

Reverse DFS from Ocean Boundaries

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

Instead of checking each cell individually, start from Pacific boundary (top/left edges) and Atlantic boundary (bottom/right edges). Use DFS to find all cells that can reach each ocean by flowing upward (reverse direction).

Brute Force DFS from Each Cell — Algorithm Steps

Step 1: For each cell, run DFS to check Pacific reachability
Step 2: For each cell, run DFS to check Atlantic reachability
Step 3: Collect cells that can reach both oceans

Visualization

Tap to expand

Step-by-Step Walkthrough

Pick Cell

Start from a cell and check reachability

DFS to Pacific

Run DFS toward top/left edges

DFS to Atlantic

Run DFS toward bottom/right edges

Code -

solution.c — C

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

int directions[4][2] = {{0,1},{1,0},{0,-1},{-1,0}};
int m, n;

void dfs(int** heights, int r, int c, bool** ocean) {
    ocean[r][c] = true;
    for (int i = 0; i < 4; i++) {
        int nr = r + directions[i][0], nc = c + directions[i][1];
        if (nr >= 0 && nr < m && nc >= 0 && nc < n &&
            !ocean[nr][nc] && heights[nr][nc] >= heights[r][c])
            dfs(heights, nr, nc, ocean);
    }
}

void solve(int** heights, int heightsSize, int colSize) {
    m = heightsSize;
    n = colSize;

    bool** pacific = (bool**)malloc(m * sizeof(bool*));
    bool** atlantic = (bool**)malloc(m * sizeof(bool*));
    for (int i = 0; i < m; i++) {
        pacific[i] = (bool*)calloc(n, sizeof(bool));
        atlantic[i] = (bool*)calloc(n, sizeof(bool));
    }

    for (int i = 0; i < m; i++) { dfs(heights, i, 0, pacific); dfs(heights, i, n-1, atlantic); }
    for (int j = 0; j < n; j++) { dfs(heights, 0, j, pacific); dfs(heights, m-1, j, atlantic); }

    printf("[");
    int first = 1;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (pacific[i][j] && atlantic[i][j]) {
                if (!first) printf(",");
                printf("[%d,%d]", i, j);
                first = 0;
            }
        }
    }
    printf("]\n");

    for (int i = 0; i < m; i++) { free(pacific[i]); free(atlantic[i]); }
    free(pacific); free(atlantic);
}

int main() {
    char buf[100000];
    int len = 0, c;
    while ((c = getchar()) != EOF) buf[len++] = c;
    buf[len] = '\0';

    int rows = 0, cols = 0, depth = 0, tempCols = 0;
    bool countedCols = false;
    for (int i = 0; i < len; i++) {
        if (buf[i] == '[') { depth++; if (depth == 2) { rows++; tempCols = 0; } }
        else if (buf[i] == ']') { if (depth == 2 && !countedCols) { cols = tempCols; countedCols = true; } depth--; }
        else if (depth == 2 && (isdigit(buf[i]) || buf[i] == '-') && (i == 0 || !isdigit(buf[i-1]))) tempCols++;
    }

    if (rows == 0) { printf("[]\n"); return 0; }

    int** heights = (int**)malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++) heights[i] = (int*)malloc(cols * sizeof(int));

    int row = -1, col = 0;
    depth = 0;
    for (int i = 0; i < len; i++) {
        if (buf[i] == '[') { depth++; if (depth == 2) { row++; col = 0; } }
        else if (buf[i] == ']') depth--;
        else if (depth == 2 && (isdigit(buf[i]) || buf[i] == '-') && (i == 0 || (!isdigit(buf[i-1]) && buf[i-1] != '-')))
            heights[row][col++] = atoi(&buf[i]);
    }

    solve(heights, rows, cols);

    for (int i = 0; i < rows; i++) free(heights[i]);
    free(heights);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

For each of m×n cells, we run DFS that can visit all m×n cells in worst case

✓ Linear Growth

Space Complexity

O(mn)

DFS recursion stack can go up to m×n depth plus visited arrays

⚡ Linearithmic Space

85.6K Views

Medium Frequency

~25 min Avg. Time

2.8K 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

Brute Force DFS from Each Cell — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler