Sol 1: DFS Cell Adjacent Counting
1. (rows, cols = width, height)
2. (perimeter = 0)
3. for (r, c) in range(rows, cols):
    a. if grid[r][c] == 1:
        perimeter += 4
        For neighbor if neighbor is == 1
            perimeter -= 1
4. return perimeter

Sol 2: BFS Iterative Track All Visited Land In Current Island
1. (rows, cols = width, height)
3. (start = any land cell (r, c))
4. (perimeter = 0)
5. (visited = {start})
6. (queue = deque([start]))
7. while queue:
   a. (r, c) = queue.popleft()
   b. For neighbor if neighbor == 0
        perimeter += 1 
        continue
   c. else neighbor (r, c) not in visited:
        visited.add(neighbor (r, c))
        queue.append(neighbor (r, c))
8. return perimeter

    def islandPerimeter(self, grid: List[List[int]]) -> int:
        
        # Note:
        # Each land cell contributes 4 edges,
        # but if two land cells are adjacent they share one edge,
        # and that shared edge removes 2 perimeter edges,
        # one from each cell.
        # Thus, for each land cell start with 4 sides
        # and subtract 1 for each adjacent land neighbor.
        # Since each shared edge is counted twice, once per cell), 
        # and subtracting per neighbor naturally handles correct perimeter.
        
        # Grid Traversal
        rows = len(grid)
        cols = len(grid[0])
        
        # Total Perimeter
        perimeter = 0
        
        # Iterate through entire grid
        # tc: O(r*c)
        for r in range(rows):
            for c in range(cols):
                
                # Only process land cells, skip water cells
                if grid[r][c] == 1:
                    
                    # Starts each land cell with a value of 4, 
                    # we subtract 1 per land neighbor due to their shared edge
                    perimeter += 4
                    
                    # 4 Neighbors:
                    #   - top, bottom, left, right
                    if r-1 >= 0 and grid[r-1][c] == 1:
                        perimeter -= 1                    
                    if r+1 <= rows-1 and grid[r + 1][c] == 1:
                        perimeter -= 1                    
                    if c-1 >= 0 and grid[r][c-1] == 1:
                        perimeter -= 1                    
                    if c-1 <= cols-1 and grid[r][c+1] == 1:
                        perimeter -= 1
        
        # overall: tc O(r*c)
        # overall: sc O(1)
        return perimeter

    def islandPerimeter(self, grid: List[List[int]]) -> int:
        
        # Note:
        # Each land cell contributes 4 edges to the perimeter.        
        # If a land cell's neighbor is also land, that shared edge
        # is internal to the island and does not belong to the perimeter.
        # For each land cell, count only the sides that face "outward",
        # either off the grid entirely, or into a water cell (0).

        # Grid Traversal
        rows = len(grid)
        cols = len(grid[0])
        directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]

        # Pick any land cell to initialize the BFS
        start = None
        for r in range(rows):
            for c in range(cols):

                # Found some land, save coordinates
                if grid[r][c] == 1:
                    start = (r, c)
                    break
            if start:
                break

        # Total perimeter count
        perimeter = 0

        # Track land we have already visited to avoid 
        # sc: O(n)
        visited = {start}

        # BFS Iterative Queue:
        # holds land cells we have queued to expand
        queue = deque([start])

        while queue:

            # Pop land cell
            r, c = queue.popleft()

            # Examine all 4 neighbors
            for dr, dc in directions:

                # New Neighbor Coordinates
                nr, nc = r + dr, c + dc

                # Valid perimeter neighbor has either neighbor of:
                #   - out of bounds of the grid
                #   - water cell
                #   - out of bounds and water
                if nr < 0 or nr >= rows or 
                   nc < 0 or nc >= cols or 
                   grid[nr][nc] == 0:
                    perimeter += 1

                    # Early Pruning:
                    # no need to explore a perimeter neighbor
                    continue

                # Neighbor was inbounds and land, 
                # if has not been visited, enqueue it to explore:
                if (nr, nc) not in visited:
                    visited.add((nr, nc))
                    queue.append((nr, nc))

        # overall: tc O(r*c)
        # overall: sc O(r*c)
        return perimeter

Sol 1: DFS Recursive Same Color Neighbor Fill
1. (rows, cols = width, height)
2. (from_color = image[start_row][start_column])
3. if from_color == to_color: 
    return image
4. dfs(r, c):
   a. if out of bounds: 
        return
   b. if image[r][c] != start_color: 
        return
   c. image[r][c] = from_color
        for neighbor:
            dfs(neighbor (r, c))
5. dfs(, sc)
6. return image

Sol 2: BFS Iterative Track All Repainted Pixels In Current Region
1. (rows, cols = width, height)
2. (from_color = image[start_row][start_column])
4. if from_color == to_color: 
    return image
5. queue = deque([(start_row, start_column)])
6. while queue:
   a. (r, c) = queue.popleft()
   b  image[r][c] = color
   c. for each neighbor (nr, nc):
        if out of bounds: 
            continue
        if image[nr][nc] != start_color: 
            continue
        queue.append((nr, nc))
8. return image

    def floodFill(self, image: List[List[int]], sr: int, sc: int, color: int) -> List[List[int]]:
        
        # Note:
        # Starting from (sr, sc), repaint every pixel that is
        # connected to it (up/down/left/right) and shares the
        # same original color. Recursion naturally stops once
        # we hit a pixel that doesn't match the original color,
        # including pixels we've already repainted (since after
        # repainting they no longer match the old color, unless
        # old color == new color, which we guard against).
        
        # Grid Traversal
        rows = len(image)
        cols = len(image[0])
        
        # Original color we are replacing
        start_color = image[sr][sc]
        
        # Edge case: if the new color is the same as the old color,
        # repainting would recurse forever (never "changes" color),
        # so just return the image unchanged.
        if start_color == color:
            return image
        
        def dfs(r, c):
            
            # Out of bounds, stop
            if r < 0 or r >= rows or c < 0 or c >= cols:
                return
            
            # Not the color we're flooding, stop
            if image[r][c] != start_color:
                return
            
            # Repaint current pixel
            image[r][c] = color
            
            # 4 Neighbors:
            #   - top, bottom, left, right
            dfs(r - 1, c)
            dfs(r + 1, c)
            dfs(r, c - 1)
            dfs(r, c + 1)
        
        # Kick off recursion from the starting pixel
        # tc: O(r*c)
        dfs(sr, sc)
        
        # overall: tc O(r*c)
        # overall: sc O(r*c) -- recursion stack in the worst case (all one color)
        return image

    def floodFill(self, image: List[List[int]], sr: int, sc: int, color: int) -> List[List[int]]:
        
        # Note:
        # Starting from (sr, sc), repaint every pixel connected to it
        # (up/down/left/right) that shares the original color.
        # Use a queue to expand outward layer by layer, only enqueueing
        # pixels that still match the original color and haven't been
        # repainted yet.

        # Grid Traversal
        rows = len(image)
        cols = len(image[0])
        directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]

        # Original color we are replacing
        start_color = image[sr][sc]

        # Edge case: if the new color is the same as the old color,
        # there is nothing to do, and checking image[r][c] != color
        # below would never be true, so short-circuit here.
        if start_color == color:
            return image

        # BFS Iterative Queue:
        # holds pixels we have queued to expand
        queue = deque([(sr, sc)])

        # Repaint the starting pixel immediately so we never
        # re-enqueue it
        image[sr][sc] = color

        while queue:

            # Pop pixel
            r, c = queue.popleft()

            # Examine all 4 neighbors
            for dr, dc in directions:

                # New Neighbor Coordinates
                nr, nc = r + dr, c + dc

                # Valid neighbor to repaint has all of:
                #   - in bounds of the grid
                #   - still matches the original color
                if nr < 0 or nr >= rows or nc < 0 or nc >= cols:
                    continue
                if image[nr][nc] != start_color:
                    continue

                # Repaint and enqueue to expand from later
                image[nr][nc] = color
                queue.append((nr, nc))

        # overall: tc O(r*c)
        # overall: sc O(r*c)
        return image

Sol 1: Recursive DFS
1. if not node: return None
2. clonedSeen = {}
3. dfs(n):
   a. copy = Node(n.val)
   b. clonedSeen[n] = copy
   c. for each neighbor in n.neighbors:
      if neighbor not in clonedSeen:
        copy.neighbors.append(dfs(neighbor))
      else:
        copy.neighbors.append(clonedSeen[neighbor])
   d. return copy
4. return dfs(node)

Sol 2: Iterative BFS
1. if not node: return None
2. clonedSeen = {node: Node(node.val)}
3. queue = deque([node])
4. while queue:
   a. current = queue.popleft()
   b. for each neighbor in current.neighbors:
      if neighbor not in clonedSeen:
        clonedSeen[neighbor] = Node(neighbor.val)
        queue.append(neighbor)
      clonedSeen[current].neighbors.append(clonedSeen[neighbor])
5. return clonedSeen[node]

    def cloneGraph(self, node: Optional['Node']) -> Optional['Node']:
        
        # Note:
        # 1. Iterate over all nodes
        # 2. For each new node, clone and add to hashmap,
        #    if neighbors are not in seen set, explore
        # 3. HashMap() will act as clone hash set and tracking seen set
        
        # Empty Check:
        # nothing to copy
        if not node:
            return None

        # Deep copy for new list
        # sc: O(n)
        clonedSeen = {}

        # tc: O(V + E) visit each node and edge once
        # sc: O(V)  for hashmap + recursion stack
        def dfs(n) -> Node:

            # New Node Found:
            # clone and add to hashmap
            copy = Node(n.val)
            clonedSeen[n] = copy

            # If neighbors are not in seen set, explore
            for neighbor in n.neighbors:
                
                # Not Yet Seen:
                if neighbor not in clonedSeen:
                    copy.neighbors.append(dfs(neighbor))

                # Already seen, grab clone from hashmap:
                else:
                    copy.neighbors.append(clonedSeen[neighbor])

            # Pass back the cloned node
            return copy

        # Grab root of cloned graph
        cloneRoot = dfs(node)

        # overall: tc O(V + E) 
        # overall: sc O(V)
        return cloneRoot

    def cloneGraph(self, node: Optional['Node']) -> Optional['Node']:
        
        # Note:
        # BFS Iterative Level By Level:
        # 1. Start at any node
        # 2. For each new node, make a clone, and
        #    check if neighbors are not in seen set, if so explore
        # 3. HashMap will serve as clone hashmap and seen set

        # Empty Check: 
        # graph has no nodes, nothing to clone
        if not node:
            return None

        # Deep copy for new list
        # sc: O(n)
        clonedSeen = {}
        clonedSeen[node] = Node(node.val)

        # BFS Iterative Queue:
        # sc: O(V)
        queue = deque()
        queue.append(node)

        # tc: O(V + E), each node and edge visited once
        # sc: O(V), for hashmap + queue
        while queue:

            # Pop node
            current = queue.popleft()

            # Explore neighbors
            for neighbor in current.neighbors:

                # Not yet cloned:
                if neighbor not in clonedSeen:
                    clonedSeen[neighbor] = Node(neighbor.val)
                    queue.append(neighbor)

                # Grab clone from hashmap:
                clonedSeen[current].neighbors.append(clonedSeen[neighbor])

        # Grab root of cloned graph
        cloneRoot = clonedSeen[node]

        # overall: tc O(V + E)
        # overall: sc O(V)
        return cloneRoot

oh! pseudocode hasn't been written yet, try another card! :)