Pacific Atlantic Water Flow - Practice Coding Problems

Pacific Atlantic Water Flow - Problem

Imagine a mysterious rectangular island surrounded by two different oceans! 🏝️ The Pacific Ocean laps against the island's left and top edges, while the Atlantic Ocean touches the right and bottom edges.

The island is divided into an m × n grid where each cell has a specific height above sea level. When it rains, water flows from higher cells to neighboring cells (north, south, east, west) that are at the same or lower height.

Your Mission: Find all cells where rainwater can flow to BOTH the Pacific and Atlantic oceans! Water can reach an ocean if it flows to any cell that borders that ocean.

Input: A 2D matrix heights where heights[r][c] represents the elevation at row r, column c.

Output: A list of coordinates [r, c] where water can reach both oceans.

Input & Output

example_1.py — Basic Island

$ 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: The cell at (0,4) has height 5. Water can flow left to reach Pacific (through height 3→2→2→1) and down to reach Atlantic (through height 4→4→1). Similarly, other cells in the result can reach both oceans through valid downhill paths.

example_2.py — Single Row

$ Input: heights = [[1,2,3]]

› Output: [[0,2]]

💡 Note: Only the rightmost cell (0,2) with height 3 can reach both oceans. It can reach Pacific by flowing left (3→2→1) and Atlantic directly since it borders the Atlantic.

example_3.py — Uniform Heights

$ Input: heights = [[1,1],[1,1]]

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

💡 Note: Since all cells have the same height (1), water can flow freely between all cells. Every cell can reach both Pacific (top-left borders) and Atlantic (bottom-right borders).

Constraints

m == heights.length
n == heights[r].length
1 ≤ m, n ≤ 200
0 ≤ heights[r][c] ≤ 10⁵
Water flows from higher or equal height to lower or equal height

Visualization

Tap to expand

Understanding the Visualization

Setup Island Grid

Create the island with height values and mark ocean borders

Pacific Flow Analysis

Start from Pacific borders (top/left) and trace uphill paths

Atlantic Flow Analysis

Start from Atlantic borders (bottom/right) and trace uphill paths

Find Dual-Drainage Points

Identify cells that can drain to both oceans

Key Takeaway

🎯 Key Insight: Instead of tracing water flow from every cell downhill to oceans (expensive), start from ocean borders and trace uphill to find all cells that can drain to each ocean (efficient)!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses a clever reverse-flow approach: instead of checking each cell individually, start DFS from ocean borders and flow uphill to mark all reachable cells. Two passes create Pacific and Atlantic reachability maps, then find their intersection in O(mn) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force DFS from Each Cell	O(m²n²)	O(mn)	For each cell, run DFS to check if water can reach both oceans
Two-Pass DFS from Ocean Borders (Optimal)	O(mn)	O(mn)	Start DFS from ocean borders, mark reachable cells, then find intersection

Brute Force DFS from Each Cell — Algorithm Steps

Iterate through every cell in the grid
For each cell, run DFS to check if water can flow to Pacific Ocean
For the same cell, run another DFS to check if water can flow to Atlantic Ocean
If both DFS calls return true, add the cell to the result
Continue until all cells are processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Current Cell

Pick a cell and start water flow simulation

DFS to Pacific

Run DFS to see if water can reach Pacific Ocean (top/left borders)

DFS to Atlantic

Run another DFS to see if water can reach Atlantic Ocean (bottom/right borders)

Check Both Conditions

If both DFS return true, add cell to result

Code -

solution.c — C

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

#define MAX_SIZE 1000

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

bool dfs(int** heights, int r, int c, char* targetOcean, bool visited[][MAX_SIZE]) {
    // Check if reached target ocean
    if (strcmp(targetOcean, "pacific") == 0) {
        if (r == 0 || c == 0) return true;
    } else { // atlantic
        if (r == m - 1 || c == n - 1) return true;
    }
    
    visited[r][c] = true;
    
    for (int i = 0; i < 4; i++) {
        int nr = r + directions[i][0];
        int nc = c + directions[i][1];
        if (nr >= 0 && nr < m && nc >= 0 && nc < n && 
            !visited[nr][nc] && heights[nr][nc] <= heights[r][c]) {
            if (dfs(heights, nr, nc, targetOcean, visited)) {
                return true;
            }
        }
    }
    
    return false;
}

int** pacificAtlantic(int** heights, int heightsSize, int* heightsColSize, int* returnSize, int** returnColumnSizes) {
    if (heightsSize == 0 || heightsColSize[0] == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    m = heightsSize;
    n = heightsColSize[0];
    
    int** result = (int**)malloc(m * n * sizeof(int*));
    *returnColumnSizes = (int*)malloc(m * n * sizeof(int));
    int count = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            // Check Pacific reachability
            bool pacificVisited[MAX_SIZE][MAX_SIZE];
            memset(pacificVisited, false, sizeof(pacificVisited));
            bool canReachPacific = dfs(heights, i, j, "pacific", pacificVisited);
            
            // Check Atlantic reachability
            bool atlanticVisited[MAX_SIZE][MAX_SIZE];
            memset(atlanticVisited, false, sizeof(atlanticVisited));
            bool canReachAtlantic = dfs(heights, i, j, "atlantic", atlanticVisited);
            
            if (canReachPacific && canReachAtlantic) {
                result[count] = (int*)malloc(2 * sizeof(int));
                result[count][0] = i;
                result[count][1] = j;
                (*returnColumnSizes)[count] = 2;
                count++;
            }
        }
    }
    
    *returnSize = count;
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

For each of the m×n cells, we potentially visit all m×n cells twice (once for each ocean), leading to quadratic complexity

⚠ Quadratic Growth

Space Complexity

O(mn)

Recursion stack depth can go up to m×n in worst case (when DFS traverses entire grid)

⚡ Linearithmic Space

180.0K Views

Medium Frequency

~25 min Avg. Time

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