2026 March 7 Problems

[daryl...@gmail.com]

Feel free to work on any of the problems you want; we'll have people present their solutions at 11:30.

Please post your solutions to this thread so others can use this as a reference.

733. Flood Fill 67.9%

3528. Unit Conversion I Medium 54.3%

815. Bus Routes Hard 47.2%

We're going to use the same Google meet link as the last few times: https://meet.google.com/xnn-kifj-jnx?pli=1

[Allen S.]

func floodFill(image [][]int, sr int, sc int, color int) [][]int {

ogColor := image[sr][sc]

if ogColor == color {

return image

}

rows, cols := len(image), len(image[0])

q := [][]int{{sr, sc}}

for len(q) > 0 {

now := q[0]

r, c := now[0], now[1]

q = q[1:]

image[r][c] = color

for _, nei := range [][]int{{r, c-1},{r-1,c},{r,c+1},{r+1,c}} {

nr, nc := nei[0], nei[1]

if !(nr >= 0 && nr < rows && nc >= 0 && nc < cols) {

continue

}

if image[nr][nc] == ogColor {

q = append(q, nei)

}

}

}

return image

}

[Anuj Patnaik]

class Solution:

def floodFill(self, image: List[List[int]], sr: int, sc: int, color: int) -> List[List[int]]:

copy_image = [row[:] for row in image]

original_color = image[sr][sc]

def should_paint(copy_image, image, i, j):

if i < 0 or i >= len(image) or j < 0 or j >= len(image[0]):

return

if copy_image[i][j] != original_color:

return

copy_image[i][j] = color

should_paint(copy_image, image, i+1, j)

should_paint(copy_image, image, i-1, j)

should_paint(copy_image, image, i, j+1)

should_paint(copy_image, image, i, j-1)

if original_color != color:

should_paint(copy_image, image, sr, sc)

return copy_image

[Wang Lijun]

class Solution:

def floodFill(self, image: List[List[int]], sr: int, sc: int, color: int) -> List[List[int]]:

ori_color = image[sr][sc]

row_count = len(image)

col_count = len(image[0])

visited = set()

def dfs(r, c):

if r < 0 or r >= row_count or c < 0 or c >= col_count:

return False

if image[r][c] != ori_color:

return False

if (r, c) in visited:

return False

image[r][c] = color

visited.add((r, c))

dfs(r+1, c)

dfs(r-1, c)

dfs(r, c+1)

dfs(r, c-1)

dfs(sr, sc)

return image

[Anuj Patnaik]

class Solution:

def baseUnitConversions(self, conversions: list[list[int]]) -> list[int]:

n = len(conversions) + 1

MOD = (10 ** 9) + 7

graph = [[] for _ in range(n)]

for i in conversions:

src = i[0]

target = i[1]

factor = i[2]

graph[src].append((target, factor))

print(graph)

conversion_arr = [0] * n

conversion_arr[0] = 1

def dfs(node):

for i in graph[node]:

child = i[0]

factor = i[1]

if conversion_arr[child] == 0:

conversion_arr[child] = (conversion_arr[node] * factor) % MOD

dfs(child)

dfs(0)

return conversion_arr

[Allen S.]

func baseUnitConversions(conversions [][]int) []int {

n := len(conversions) + 1

g := make(map[int]map[int]int) // adj list

for _, v := range conversions {

s, t, f := v[0], v[1], v[2]

if _, ok := g[s]; !ok {

g[s] = make(map[int]int)

}

g[s][t] = f

}

q := [][]int{{0,1}}

res := make([]int, n)

for len(q) > 0 {

now := q[0]

q = q[1:]

res[now[0]] = now[1]

for nei, factor := range g[now[0]] {

q = append(q,[]int{nei, now[1] * factor % (1e9 + 7)})

}

}

return res

}

[vinay]

733. Flood Fill 67.9%

time O(N), space O(N)

class Solution {

    public int[][] floodFill(int[][] image, int sr, int sc, int color) {

        if (image[sr][sc] == color) {

            return image;

        }

        int[][] dirs = new int[][]{ {1,0}, {-1,0}, {0,-1}, {0,1}};

        Deque<int[]> queue = new ArrayDeque<>();

        queue.offer(new int[]{sr,sc});

        int boundaryRow = image.length;

        int boundaryCol = image[0].length;

        int srcColor = image[sr][sc];

        while(queue.size() > 0){

            int[] pixel = queue.poll();

            int row = pixel[0];

            int col = pixel[1];

            image[row][col] =  color;

            for(int[] dir : dirs){

                int nextRow = dir[0] + row;

                int nextCol = dir[1] + col;

                if(nextRow >= 0 && nextRow < boundaryRow && nextCol >= 0 &&

                        nextCol < boundaryCol &&  image[nextRow][nextCol] == srcColor){

                   queue.offer(new int[]{nextRow, nextCol});            

                }

            }

        }

        return image;

    }

}

--
whatspp group: http://whatsapp.techbayarea.us/
---
You received this message because you are subscribed to the Google Groups "leetcode-meetup" group.
To unsubscribe from this group and stop receiving emails from it, send an email to leetcode-meet...@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/leetcode-meetup/a33adb6d-f539-43c7-ad4a-cce9d8898073n%40googlegroups.com.

[Wang Lijun]

class Solution:

def floodFill(self, image: List[List[int]], sr: int, sc: int, color: int) -> List[List[int]]:

# starting pixel original color

ori_color = image[sr][sc]

r_count = len(image)

c_count = len(image[0])

if ori_color == color:

return image

dq = deque([(sr, sc)])

while dq:

r, c = dq.popleft()

image[r][c] = color

if r - 1 >= 0 and image[r-1][c] == ori_color:

dq.append((r-1, c))

if c - 1 >= 0 and image[r][c-1] == ori_color:

dq.append((r, c-1))

if r + 1 <= r_count -1 and image[r+1][c] == ori_color:

dq.append((r+1, c))

if c + 1 <= c_count -1 and image[r][c+1] == ori_color:

dq.append((r, c+1))

return image