LeetCode problem 36 “Valid Sudoku” is a classic example of a backtracking problem. The goal is to determine if a 9 x 9 Sudoku board is valid based on specific rules. This problem requires strong algorithmic skills and a good understanding of the rules of Sudoku. The significance of this problem lies in the fact that Sudoku is a popular game with its own set of rules, and it is a great exercise for strengthening one’s problem-solving skills in programming.

**Contents**show

## Understanding the LeetCode 36 Problem

### What is a Valid Sudoku?

A valid Sudoku is a 9 x 9 grid with 81 cells divided into nine sub-grids, where each row, column, and sub-grid contains unique digits from 1 to 9. Only the filled cells need to be validated according to the following rules:

- Each row must contain the digits 1–9 without repetition.
- Each column must contain the digits 1–9 without repetition.

### Case Studies: Solving the LeetCode 36 Problem

#### Case 1: Solving a Sudoku with Fully Filled Cells

To validate a completely filled 9×9 Sudoku board:

- Iterate through each row and column to check if there are any duplicate digits.
- Divide the board into nine 3 x 3 sub-grids and check if each sub-grid only contains unique digits.
- If all rows, columns, and sub-grids contain unique digits, return true as the Sudoku board is valid.

#### Case 2: Solving a Sudoku with Blank Spaces

To validate a partially filled 9×9 Sudoku board with blank cells:

- Iterate through each row and column to check if there are any duplicate digits.
- Divide the board into nine 3 x 3 sub-grids and check if each sub-grid only contains unique digits.
- For each blank cell, check all possible digits that could fill the cell without violating the Sudoku rules.
- If all rows, columns, and sub-grids contain unique digits and all blank cells can be filled according to the Sudoku rules, return true as the Sudoku board is valid.

#### Case 3: Handling Invalid Sudokus

To detect invalid Sudokus and return false:

- If any row, column, or sub-grid contains duplicate digits, return false.
- If any blank cell cannot be filled with a digit without violating the Sudoku rules, return false.

## Solving the LeetCode 36 Problem

The LeetCode 36 problem is a data structure problem that determines whether a 9 x 9 Sudoku board is valid or not. Solving this problem involves validating every row, column, and 3×3 grid in the Sudoku board.

### Step 1: Checking the Rows

To validate every row in the Sudoku board, we need to check if each row contains the digits 1-9 without repetition. We can achieve this by using hash sets to keep track of digits already in a row. If we encounter a repeated digit or a digit greater than 9, then we can return false because the row is invalid. If all rows pass this check, then the Sudoku board is still valid.

### Step 2: Checking the Columns

Validating every column in the Sudoku board requires a similar approach to checking the rows. We can iterate through each column and maintain a hash set to keep track of digits already present in a column. If we encounter a repeated digit or a digit greater than 9, then we return false because the column is invalid. If all columns pass this check, then the Sudoku board is still valid.

### Step 3: Checking the 3×3 Grids

Validating every 3×3 grid in the Sudoku board is slightly different from checking the rows and columns. We need to iterate through all the 3×3 grids and maintain a hash set to keep track of digits already present in a particular grid. To find the starting index of each grid, we can use modulus to find the row and column indices that correspond to a particular grid. If we encounter a repeated digit or a digit greater than 9 in one of the grids, then we return false because that particular grid is invalid. If all the 3×3 grids pass this check, then the entire Sudoku board is valid.

## Optimizing Time and Space Complexity

### Time Complexity Analysis

The LeetCode 36 problem requires us to determine if a 9×9 Sudoku board is valid. We can achieve this by checking each row, column, and sub-square to ensure that they do not contain any repeated values from 1 to 9. The time complexity of this algorithm is O(n^2), where n is the size of the board (9×9=81). We iterate through the board once for each check we perform, resulting in a time complexity of O(3n^2) or O(n^2).

To optimize the time complexity of this algorithm, we can use set data structures to keep track of the numbers in each row, column, and sub-square. This will allow us to quickly determine if a value has been repeated, without having to iterate through the entire row or column each time. By using this technique, we can achieve a time complexity of O(n), which is much faster than our original O(n^2) solution.

### Space Complexity Analysis

The space complexity of the LeetCode 36 problem depends on the size of the input (9×9 Sudoku board), as well as the space required for our data structures. The largest data structure that we use is the set, which has a space complexity of O(n). Therefore, the space complexity of our algorithm is O(n) as well, since we are only using a single set for each row, column, and sub-square check.

To optimize the space complexity of this algorithm, we can use bit manipulation techniques to represent the numbers in each row, column, and sub-square. By using a single 9-bit integer to represent the numbers from 1 to 9, we can reduce the space required for each set to just 1 integer. This will greatly reduce the overall space complexity of our algorithm, while still allowing us to achieve the same result.

## References

LeetCode problem statement for “36. Valid Sudoku”

- Set a timer to create a sense of urgency and help you stay focused
- Focus on a single row, column, or square to spot patterns and progress more quickly
- Practice one new technique at a time for five minutes each to build your skillset gradually
- Get a fast start by locating the numbers that appear most frequently in the grid
- Look for single candidate values to eliminate possibilities and narrow down your choices
- Work on scanning techniques to quickly identify patterns and fill in missing values
- Avoid focusing too long on a single spot by switching it up frequently