dir[4][2]; 4 個方向，每個方向需要 2 個數字：x 改多少、y 改多少。

visited[x][y] = 1; 1 = 走過；0 = 沒走過。

dir[0]; 目前這個方向的 x 變化量；dir[1] 是 y 變化量。

      Pacific
         ↓
    y=0  1  2  3

x=0 1 2 3 4
x=1 2 3 4 5
x=2 3 4 5 6
↑ ↓
Pacific Atlantic
↓
Atlantic

Ocean 四條邊當起點
↓
上、下、左、右
↓
inside
&& 沒走過
&& 未來高度 >= 現在高度
↓
DFS
↓
Pacific && Atlantic

i 表 index目前是第幾個位置」。

height =
1 2
4 3

Pacific 接觸「上＋左」：

Pacific 起點：
(0,0) (0,1) ← 上邊
(1,0) ← 左邊

Atlantic 接觸「下＋右」：

Atlantic 起點：
(1,0) (1,1) ← 下邊
(0,1) ← 右邊

所以不是：

一個起點 → DFS

而是：

Pacific 的所有邊界起點 → DFS → pacific visited
Atlantic 的所有邊界起點 → DFS → atlantic visited

重複的角落沒關係，因為 visited 已經是 true 就不會重走。

1 2
4 3

先 Pacific。

起點 (0,0)=1：

1 → 2 可以，2 >= 1
↓
4 可以，4 >= 1

所以 Pacific 最後可以標：

✓ ✓
✓ ?

從 (0,1)=2 還能往 (1,1)=3：

3 >= 2

所以變：

✓ ✓
✓ ✓

Atlantic 再從下邊＋右邊反向走，最後也會得到自己的 visited。

最後：

pacific[x][y] && atlantic[x][y]

才決定答案。

vector(maxY, false)

= 建立「一整列」，有 maxY 格，每格一開始都是 false。

例如 maxY = 3：

false false false

再外面：

vector<vector>(maxX, ...)

= 建立 maxX 列。

例如 2×3：

false false false
false false false

所以：

pacific

是 Pacific 的 2D 地圖。

atlantic

是 Atlantic 的 2D 地圖。

vector 可以理解成 dynamic array（動態陣列）；vector<vector> 就是二維動態陣列。

char 是每一格存的型別；這裡只需要：

false / 0 = 還沒走到
true / 1 = 走到了

DFS 會做：

visited[x][y] = true;

所以最後可能：

pacific

true true
true false

另一張：

atlantic

false true
true true

最後

if (pacific[x][y] && atlantic[x][y])

也就是：同一個 (x,y) 在 Pacific 是 true，而且在 Atlantic 也是 true → 存進 answer。

class Solution {
public:
    int maxX, maxY;
    int dx[4] = {-1, 1, 0, 0};  // 上、下、左、右
    int dy[4] = {0, 0, -1, 1};

    // 從 Ocean 反向往高處 DFS
    void dfs(vector<vector<int>>& height, int x, int y, vector<vector<char>>& visited) {
        visited[x][y] = true;  // 目前位置已走過

        for (int i = 0; i < 4; ++i) {
            int nx = x + dx[i];  // 下一個 x
            int ny = y + dy[i];  // 下一個 y

            bool inside = nx >= 0 && nx < maxX && ny >= 0 && ny < maxY;  // Grid 邊界

            if (inside &&
                !visited[nx][ny] &&
                height[nx][ny] >= height[x][y]) {  // 未來 >= 現在，往高處爬

                dfs(height, nx, ny, visited);
            }
        }
    }

    vector<vector<int>> pacificAtlantic(vector<vector<int>>& height) {
        maxX = height.size();
        maxY = height[0].size();
 
        vector<vector<char>> pacific(maxX, vector<char>(maxY, false));// 第一張：Pacific；第二張：Atlantic
        vector<vector<char>> atlantic(maxX, vector<char>(maxY, false));

        for (int y = 0; y < maxY; ++y) {// 上邊 Pacific、下邊 Atlantic
            dfs(height, 0, y, pacific);
            dfs(height, maxX - 1, y, atlantic);
        }

        for (int x = 0; x < maxX; ++x) {// 左邊 Pacific、右邊 Atlantic
            dfs(height, x, 0, pacific);
            dfs(height, x, maxY - 1, atlantic);
        }

        vector<vector<int>> answer;// 兩張都是 true → 答案

        for (int x = 0; x < maxX; ++x) {
            for (int y = 0; y < maxY; ++y) {
                if (pacific[x][y] && atlantic[x][y])
                    answer.push_back({x, y});
            }
        }

        return answer;
    }
};