Something is off - I'm running this with essentially the solution:

class Solution {
  findIslandPerimeter(matrix) {
    // TODO: Write your code here
    // dfs 
    const nRows = matrix.length, nCols = matrix[0].length;
    const visited = new Array(nRows).fill(false).map(() => new Array(nCols).fill(false));
    
    for (let row = 0; row < nRows; row++) {
      for (let col = 0; col < nCols; col++) {
        if (matrix[row][col] === 1) {
          // for each cell, check if === 1 and not visited, and do dfs
          return this.dfs(row, col, matrix, visited);
        }
      }
    }
  }

  // for each dfs
  dfs(row, col, matrix, visited) {
    // each cell should return its perimeter

    // base case:
    // out of bounds - return 1
    if (!(0 <= row && row < matrix.le

Key intuition:

If there is a island block (a 1 in the matrix) the perimeter of that singular block is 4 - the number of other island blocks it is connected to.

So if you go to every island block and check the 4 directions from it count out of the sides are connected then subtract that from 4 we know the perimeter of that block.

So if you do that for every island block and sum it up it will give you the perimeter for the island in the matrix. This in theory would work to find perimeter of multiple islands, if they had lakes too.

def findIslandPerimeter(self, matrix):
    # TODO: Write your code here
    rows = len(matrix)
    cols = len(matrix[0])
    deltas = [(1,0),(-1,0),(0,1),(0,-1)]
    def check_around(i,j):
      connected = 0
      for i_delta, j_delta in deltas:
   

class Solution:
  
  def get_neighbors(self, matrix, i, j):
    neighbors = []
    rows = [-1, 0, 1, 0]
    cols = [0, 1, 0, -1]
    for k in range(len(rows)):
      x = rows[k] + i
      y = cols[k] + j
      if x >= 0 and x < len(matrix) and y >= 0 and y < len(matrix[0]):
        neighbors.append((x, y))
    return neighbors
  
  def cacl_perimeter(self, matrix, i, j):
    perimeter = 0
    # top perimeter
    if  i == 0 or (i - 1 >= 0 and matrix[i - 1][j] == 0):
      perimeter += 1
    # bottom perimeter  
    if  i == len(matrix) - 1 or (i + 1 < len(matrix) and matrix[i + 1][j] == 0):
      perimeter += 1
    # left perimeter
    if  j == 0 or (j - 1 >= 0 and matrix[i][j - 1] == 0):
      perimeter += 1
    # right perimeter  
    if  j == len(matrix[0]) - 1 or (j + 1 <