Formatted question description: https://leetcode.ca/all/1706.html

1706. Where Will the Ball Fall

Level

Medium

Description

You have a 2-D grid of size m x n representing a box, and you have n balls. The box is open on the top and bottom sides.

Each cell in the box has a diagonal board spanning two corners of the cell that can redirect a ball to the right or to the left.

A board that redirects the ball to the right spans the top-left corner to the bottom-right corner and is represented in the grid as 1.
A board that redirects the ball to the left spans the top-right corner to the bottom-left corner and is represented in the grid as -1.

We drop one ball at the top of each column of the box. Each ball can get stuck in the box or fall out of the bottom. A ball gets stuck if it hits a “V” shaped pattern between two boards or if a board redirects the ball into either wall of the box.

Return an array answer of size n where answer[i] is the column that the ball falls out of at the bottom after dropping the ball from the i-th column at the top, or -1 if the ball gets stuck in the box.

Example 1:

Image text

Input: grid = [[1,1,1,-1,-1],[1,1,1,-1,-1],[-1,-1,-1,1,1],[1,1,1,1,-1],[-1,-1,-1,-1,-1]]

Output: [1,-1,-1,-1,-1]

Explanation: This example is shown in the photo.

Ball b0 is dropped at column 0 and falls out of the box at column 1.

Ball b1 is dropped at column 1 and will get stuck in the box between column 2 and 3 and row 1.

Ball b2 is dropped at column 2 and will get stuck on the box between column 2 and 3 and row 0.

Ball b3 is dropped at column 3 and will get stuck on the box between column 2 and 3 and row 0.

Ball b4 is dropped at column 4 and will get stuck on the box between column 2 and 3 and row 1.

Example 2:

Input: grid = [[-1]]

Output: [-1]

Explanation: The ball gets stuck against the left wall.

Constraints:

m == grid.length
n == grid[i].length
1 <= m, n <= 100
grid[i][j] is 1 or -1.

Solution

For each ball, use the corresponding elements in grid to determine whether the ball moves to the right cell or the left cell. If the ball moves out of the bound, which means the board redirects the ball into either wall, return -1. If the two adjacent cells have different values in grid, which means the ball hits a “V” shaped pattern between two boards, return -1. If neither case happens, the ball moves to the down cell. Repeat the process until the ball gets stucked or the ball reaches the bottom, and then the corresponding answer for the ball can be obtained.

class Solution {
    public int[] findBall(int[][] grid) {
        int columns = grid[0].length;
        int[] bottoms = new int[columns];
        for (int i = 0; i < columns; i++)
            bottoms[i] = findBottom(grid, i);
        return bottoms;
    }

    public int findBottom(int[][] grid, int start) {
        int rows = grid.length, columns = grid[0].length;
        int row = 0, column = start;
        while (row < rows) {
            int curr = grid[row][column];
            if (curr == 1)
                column++;
            else
                column--;
            if (column < 0 || column >= columns)
                return -1;
            if (curr != grid[row][column])
                return -1;
            row++;
        }
        return column;
    }
}

############

class Solution {
    private int m;
    private int n;
    private int[][] grid;

    public int[] findBall(int[][] grid) {
        m = grid.length;
        n = grid[0].length;
        this.grid = grid;
        int[] ans = new int[n];
        for (int j = 0; j < n; ++j) {
            ans[j] = dfs(0, j);
        }
        return ans;
    }

    private int dfs(int i, int j) {
        if (i == m) {
            return j;
        }
        if (j == 0 && grid[i][j] == -1) {
            return -1;
        }
        if (j == n - 1 && grid[i][j] == 1) {
            return -1;
        }
        if (grid[i][j] == 1 && grid[i][j + 1] == -1) {
            return -1;
        }
        if (grid[i][j] == -1 && grid[i][j - 1] == 1) {
            return -1;
        }
        return grid[i][j] == 1 ? dfs(i + 1, j + 1) : dfs(i + 1, j - 1);
    }
}

// OJ: https://leetcode.com/problems/where-will-the-ball-fall/
// Time: O(MN)
// Space: O(N)
class Solution {
public:
    vector<int> findBall(vector<vector<int>>& G) {
        int M = G.size(), N = G[0].size();
        vector<int> b(N);
        iota(begin(b), end(b), 0);
        for (int i = 0; i < M; ++i) {
            for (int j = 0; j < N; ++j) {
                if (b[j] == -1) continue;
                if (G[i][b[j]] == 1) {
                    if (b[j] == N -1 || G[i][b[j] + 1] == -1) b[j] = -1;
                    else b[j]++;
                } else {
                    if (b[j] == 0 || G[i][b[j] - 1] == 1) b[j] = -1;
                    else b[j]--;
                }
            }
        }
        return b;
    }
};

class Solution:
    def findBall(self, grid: List[List[int]]) -> List[int]:
        m, n = len(grid), len(grid[0])

        def dfs(i, j):
            nonlocal m, n
            if i == m:
                return j
            if j == 0 and grid[i][j] == -1:
                return -1
            if j == n - 1 and grid[i][j] == 1:
                return -1
            if grid[i][j] == 1 and grid[i][j + 1] == -1:
                return -1
            if grid[i][j] == -1 and grid[i][j - 1] == 1:
                return -1
            return dfs(i + 1, j + 1) if grid[i][j] == 1 else dfs(i + 1, j - 1)

        return [dfs(0, j) for j in range(n)]

############

# 1706. Where Will the Ball Fall
# https://leetcode.com/problems/where-will-the-ball-fall/

class Solution:
    def findBall(self, grid: List[List[int]]) -> List[int]:
        res = []
        
        for c in range(len(grid[0])):
            res.append(self.helper(grid, 0, c))
        
        return res
    
    def helper(self, grid, r, c):
        if r == len(grid): return c
        
        if r >= 0 and r < len(grid) and c >= 0 and c < len(grid[r]):
            
            if c == 0 and grid[r][c] == -1: return -1
            
            elif c == len(grid[r]) - 1 and grid[r][c] == 1: return -1
            
            elif c < len(grid[r]) - 1 and grid[r][c] == 1 and grid[r][c+1] == -1: return -1
            
            elif c > 0 and grid[r][c-1] == 1 and grid[r][c] == -1: return -1
            
            return self.helper(grid, r+1, c + grid[r][c])
        
        return -1

func findBall(grid [][]int) []int {
	m, n := len(grid), len(grid[0])

	var dfs func(i, j int) int
	dfs = func(i, j int) int {
		if i == m {
			return j
		}
		if j == 0 && grid[i][j] == -1 {
			return -1
		}
		if j == n-1 && grid[i][j] == 1 {
			return -1
		}
		if grid[i][j] == 1 && grid[i][j+1] == -1 {
			return -1
		}
		if grid[i][j] == -1 && grid[i][j-1] == 1 {
			return -1
		}
		if grid[i][j] == 1 {
			return dfs(i+1, j+1)
		}
		return dfs(i+1, j-1)
	}

	var ans []int
	for j := 0; j < n; j++ {
		ans = append(ans, dfs(0, j))
	}
	return ans
}

function findBall(grid: number[][]): number[] {
    const m = grid.length;
    const n = grid[0].length;
    const res = new Array(n).fill(0);
    const dfs = (i: number, j: number) => {
        if (i === m) {
            return j;
        }
        if (grid[i][j] === 1) {
            if (j === n - 1 || grid[i][j + 1] === -1) {
                return -1;
            }
            return dfs(i + 1, j + 1);
        } else {
            if (j === 0 || grid[i][j - 1] === 1) {
                return -1;
            }
            return dfs(i + 1, j - 1);
        }
    };
    for (let i = 0; i < n; i++) {
        res[i] = dfs(0, i);
    }
    return res;
}

impl Solution {
    fn dfs(grid: &Vec<Vec<i32>>, i: usize, j: usize) -> i32 {
        if i == grid.len() {
            return j as i32;
        }
        if grid[i][j] == 1 {
            if j == grid[0].len() - 1 || grid[i][j + 1] == -1 {
                return -1;
            }
            Self::dfs(grid, i + 1, j + 1)
        } else {
            if j == 0 || grid[i][j - 1] == 1 {
                return -1;
            }
            Self::dfs(grid, i + 1, j - 1)
        }
    }

    pub fn find_ball(grid: Vec<Vec<i32>>) -> Vec<i32> {
        let m = grid.len();
        let n = grid[0].len();
        let mut res = vec![0; n];
        for i in 0..n {
            res[i] = Self::dfs(&grid, 0, i);
        }
        res
    }
}

1706 - Where Will the Ball Fall

1706. Where Will the Ball Fall

Level

Description

Solution

All Problems

All Solutions

Welcome to Subscribe On Youtube

1706. Where Will the Ball Fall

Level

Description

Solution

All Problems

All Solutions