Add: Add 2025/1/31

whats2000 · whats2000 · commit c48a7eabdb31 · 2025-01-31T15:37:38.000+08:00
diff --git a/827-Making A Large Island/Note.md b/827-Making A Large Island/Note.md
@@ -0,0 +1,149 @@
+# 827. Making A Large Island
+
+You are given an `n x n` binary matrix `grid`. 
+You are allowed to change at most one `0` to be `1`.
+
+Return the size of the largest island in `grid` after applying this operation.
+
+An island is a 4-directionally connected group of `1`s.
+
+## 基礎思路
+
+我們可以先把所有島嶼找出來，並給他們編號，紀錄每個島嶼的大小。
+然後我們遍歷所有的"海洋"，將其變成"陸地"，並把新的島嶼的大小計為 1 加上四周的島嶼大小。
+這樣就能有效的找出最大的島嶼。
+
+> Tips:
+> - 我們可以用 DFS 或 BFS 來找出島嶼。並給予編號，紀錄大小。
+> - 為了進一步減少記憶體使用，我們可以利用 `grid` 來紀錄每個島嶼的編號。由於 `grid` 中的 0 與 1 已經被使用，我們可以用 2 以上的數字來表示島嶼的編號。
+
+## 解題步驟
+
+### Step 1: 初始化起點 id 與 大小 Set
+
+```typescript
+// 由於 `grid` 是 n x n 的二維陣列，我們紀錄一個 n 即可
+const n = grid.length;
+
+// 島嶼的編號從 2 開始，以區分 1 與 0
+let currentIslandId = 2;
+
+// 紀錄每個島嶼的大小
+const islandSizes: Record<number, number> = {};
+```
+
+### Step 2: 定義 DFS 函數
+
+```typescript
+function dfs(row: number, col: number, islandId: number): void {
+  // 基礎情況：超出邊界或不是當前島嶼的一部分
+  if (row < 0 || col < 0 || row >= n || col >= n || grid[row][col] !== 1) {
+    return;
+  }
+
+  grid[row][col] = islandId; // 標記當前位置為當前島嶼的一部分
+  islandSizes[islandId]++;   // 增加當前島嶼的大小
+
+  // 遞歸檢查四周的位置
+  dfs(row - 1, col, islandId);
+  dfs(row + 1, col, islandId);
+  dfs(row, col - 1, islandId);
+  dfs(row, col + 1, islandId);
+}
+```
+
+### Step 3: 遍歷所有位置，找出島嶼
+
+```typescript
+for (let row = 0; row < n; row++) {
+  for (let col = 0; col < n; col++) {
+    // 跳過水域或已經標記過的島嶼
+    if (grid[row][col] !== 1) {
+      continue;
+    }
+
+    // 初始當前島嶼的大小
+    islandSizes[currentIslandId] = 0;
+
+    // 用 DFS 找出當前島嶼的大小並標記方格
+    dfs(row, col, currentIslandId);
+
+    // 移動到下一個島嶼 id
+    currentIslandId++;
+  }
+}
+```
+
+### Step 4: Helper 函數，計算相鄰島嶼的大小
+
+```typescript
+function getConnectedIslandSize(row: number, col: number, visitedIslands: Set<number>): number {
+  // 基礎情況：超出邊界或是水域
+  if (row < 0 || col < 0 || row >= n || col >= n || grid[row][col] <= 1) {
+    return 0;
+  }
+
+  // 取得當前位置的島嶼編號
+  const islandId = grid[row][col];
+  if (visitedIslands.has(islandId)) {
+    return 0;
+  }
+
+  visitedIslands.add(islandId); // 標記當前島嶼已經被計算過
+  return islandSizes[islandId]; // 回傳當前島嶼的大小
+}
+```
+
+### Step 5: 遍歷所有水域，找出最大島嶼
+
+```typescript
+let maxIslandSize = 0;
+
+// 旗標：是否有水域
+let haveZeroCell = false;
+
+for (let row = 0; row < n; row++) {
+  for (let col = 0; col < n; col++) {
+    if (grid[row][col] === 0) {
+      // 我們找到了水域，設定旗標
+      haveZeroCell = true;
+
+      // 追蹤已經計算過的島嶼
+      const visitedIslands = new Set<number>();
+
+      // 計算潛在的島嶼大小
+      let potentialSize = 1; // 由於我們將水域變成陸地，所以大小起始為 1
+
+      // 檢查四周的島嶼
+      potentialSize += getConnectedIslandSize(row - 1, col, visitedIslands);
+      potentialSize += getConnectedIslandSize(row + 1, col, visitedIslands);
+      potentialSize += getConnectedIslandSize(row, col - 1, visitedIslands);
+      potentialSize += getConnectedIslandSize(row, col + 1, visitedIslands);
+
+      // 更新最大島嶼大小
+      maxIslandSize = Math.max(maxIslandSize, potentialSize);
+    }
+  }
+}
+```
+
+### Step 6: 判定是否有水域，回傳結果
+
+```typescript
+// 如果有水域，回傳最大島嶼大小；否則回傳 n * n (所有方格都是島嶼)
+return haveZeroCell ? maxIslandSize : n * n;
+```
+
+## 時間複雜度
+- 計算島嶼大小會使用 DFS，由於不會重複計算，所以時間複雜度為 $O(n^2)$
+- 檢查所有水域的四周島嶼大小，會需要遍歷所有方格，所以時間複雜度為 $O(n^2)$
+- 總時間複雜度為 $O(n^2)$
+
+> $O(n^2)$
+
+## 空間複雜度
+- 紀錄島嶼大小的 `islandSizes` 在最極端的情況下 (即棋盤狀的島嶼) 會使用有 $\frac{n^2}{2}$ 個島嶼，所以空間複雜度為 $O(n^2)$
+- DFS 遞歸會最差情況下使用 $O(n^2)$ 的堆疊空間
+- 總空間複雜度為 $O(n^2)$
+
+> $O(n^2)$
diff --git a/827-Making A Large Island/answer.ts b/827-Making A Large Island/answer.ts
@@ -0,0 +1,122 @@
+/**
+ * Finds the size of the largest island that can be formed by changing at most one `0` to `1`.
+ * An island is defined as a 4-directionally connected group of `1`s.
+ *
+ * @param grid - The input n x n binary grid.
+ * @returns The size of the largest island after flipping one `0` to `1`.
+ */
+function largestIsland(grid: number[][]): number {
+  const n = grid.length;
+
+  // Island IDs start from 2 to distinguish from 1s and 0s
+  let currentIslandId = 2;
+
+  // Maps islandId to its size
+  const islandSizes: Record<number, number> = {};
+
+  /**
+   * Performs DFS to label the current island and count its size.
+   *
+   * @param row - The current row index.
+   * @param col - The current column index.
+   * @param islandId - The ID assigned to the current island.
+   */
+  function dfs(row: number, col: number, islandId: number): void {
+    // Base case: Out of bounds or not part of the current island
+    if (row < 0 || col < 0 || row >= n || col >= n || grid[row][col] !== 1) {
+      return;
+    }
+
+    grid[row][col] = islandId; // Label this cell with the current islandId
+    islandSizes[islandId]++;   // Increment the size of the current island
+
+    // Explore all 4 directions
+    dfs(row - 1, col, islandId);
+    dfs(row + 1, col, islandId);
+    dfs(row, col - 1, islandId);
+    dfs(row, col + 1, islandId);
+  }
+
+  /**
+   * 1. Label all islands and calculate their sizes
+   */
+  for (let row = 0; row < n; row++) {
+    for (let col = 0; col < n; col++) {
+      // Skip water cells and already labeled islands
+      if (grid[row][col] !== 1) {
+        continue;
+      }
+
+      // Initialize the size of the current island
+      islandSizes[currentIslandId] = 0;
+
+      // Perform DFS to label the current island and count its size
+      dfs(row, col, currentIslandId);
+
+      // Move to the next island ID
+      currentIslandId++;
+    }
+  }
+
+  /**
+   * Calculates the size contributed by neighboring islands when flipping a `0` to `1`.
+   *
+   * @param row - The row index of the `0` cell.
+   * @param col - The column index of the `0` cell.
+   * @param visitedIslands - Set to track visited islands and avoid double counting.
+   * @returns The size contribution of neighboring islands.
+   */
+  function getConnectedIslandSize(row: number, col: number, visitedIslands: Set<number>): number {
+    // Out of bounds or water cell or already visited island
+    if (row < 0 || col < 0 || row >= n || col >= n || grid[row][col] <= 1) {
+      return 0;
+    }
+
+    // Get the island ID of the neighboring island
+    const islandId = grid[row][col];
+    if (visitedIslands.has(islandId)) {
+      return 0;
+    }
+
+    visitedIslands.add(islandId); // Mark this island as visited
+    return islandSizes[islandId]; // Return its size
+  }
+
+  let maxIslandSize = 0;
+
+  // Flag to check if any 0 was found in the grid
+  let haveZeroCell = false;
+
+  /**
+   * 2. Check each `0` cell to find the maximum possible island size.
+   */
+  for (let row = 0; row < n; row++) {
+    for (let col = 0; col < n; col++) {
+      if (grid[row][col] === 0) {
+        // A 0 was found, so flag it
+        haveZeroCell = true;
+
+        // Track visited neighboring islands
+        const visitedIslands = new Set<number>();
+
+        // Calculate the potential island size by flipping this 0
+        let potentialSize = 1; // Start with 1 for the flipped 0 itself
+
+        // Check the size of neighboring islands in 4 directions
+        potentialSize += getConnectedIslandSize(row - 1, col, visitedIslands);
+        potentialSize += getConnectedIslandSize(row + 1, col, visitedIslands);
+        potentialSize += getConnectedIslandSize(row, col - 1, visitedIslands);
+        potentialSize += getConnectedIslandSize(row, col + 1, visitedIslands);
+
+        // Update the maximum island size
+        maxIslandSize = Math.max(maxIslandSize, potentialSize);
+      }
+    }
+  }
+
+  /**
+   * 3. Return the maximum island size after flipping one `0` to `1`.
+   *    If no `0` was found, return the size of the entire grid.
+   */
+  return haveZeroCell ? maxIslandSize : n * n;
+}
