# Sudoku Solver in Java: Backtracking Algorithm

This Java program features an efficient backtracking algorithm to solve 9x9 Sudoku puzzles. The Sudoku class, equipped with a Cell representation, validates number placements based on Sudoku rules. The solve method employs backtracking, systematically filling cells and undoing choices when needed. The main method demonstrates the solver's application, initializing a Sudoku board with starting values, attempting to solve it, and presenting both the initial and solved states. This implementation showcases a concise yet robust solution for Sudoku enthusiasts and programming enthusiasts alike.

## Java Sudoku Solver: Efficient 9x9 Puzzle Solution with Backtracking

The provided Java code implements an efficient backtracking algorithm for solving 9x9 Sudoku puzzles. The program defines a Sudoku class, complemented by a Cell representation, facilitating the validation of number placements in adherence to Sudoku rules. Employing backtracking in the solve method ensures a systematic approach to solving the puzzle. The main method showcases practical usage, initializing the Sudoku board with starting values and demonstrating the solver's proficiency in solving Sudoku puzzles. This code serves as a valuable resource for individuals seeking to understand or implement Sudoku-solving algorithms in Java, providing a clear and concise solution. If you're looking for assistance with your Java assignment related to algorithms or puzzle-solving, this code can serve as a helpful reference.

## Block 1. Cell Class

```class Cell { int row; int col; int value; }```

Description: Defines a simple class to represent a cell in the Sudoku grid.

Attributes:

• row: Row index of the cell.
• col: Column index of the cell.
• value: Value stored in the cell.

## Block 2. Sudoku Class:

```class Sudoku { int size; Cell[][] cells; Sudoku(int size) { this.size = size; cells = new Cell[size][size]; }```

Description: Defines the Sudoku class responsible for managing the Sudoku board.

Attributes:

• size: Size of the Sudoku board (e.g., 9 for a standard 9x9 Sudoku).
• cells: 2D array to store the cells of the Sudoku board.

Constructor:

• Initializes the Sudoku board with the given size.

## Block 3. canPlace Method:

```boolean canPlace(int row, int col, int num) { // ... (see next) }```

Description: Checks if a number can be placed at a specified cell without violating Sudoku rules.

Parameters:

• row: Row index of the cell.
• col: Column index of the cell.
• num: Number to be checked.

Logic:

• Checks the row, column, and the 3x3 box to ensure that num is not already present.

Returns:

• true if num can be placed; otherwise, false.

## Block 4. solve Method

```boolean solve() { // ... (see next) }```

Description: Solves the Sudoku board using a backtracking algorithm.

Logic:

• Iterates through each cell.
• If the cell is empty (has a value of 0), tries placing numbers from 1 to size.
• Recursively calls itself for the next empty cell.
• Backtracks if the solution is not valid.

Returns:

• true if the Sudoku is solved; otherwise, false.

## Block 5. Main Method:

```public static void main(String[] args) { // ... (see next) }```

Description: Entry point of the program where a Sudoku instance is created and solved.

Initialization:

• Creates a 9x9 Sudoku board.
• Initializes the board with starting values.

Printing:

• Prints the initial Sudoku board.
• Attempts to solve the Sudoku board and prints the result.

## Initializing the Sudoku Board:

```int[][] startingValues = { /* ... */ }; for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { // ... (see next) } }```

Description: Initializes the Sudoku board with starting values.

Nested Loop:

• Iterates through each cell in the 9x9 grid.
• Creates a new Cell instance and assigns row, column, and value.

## Block 7. Print Initial Board:

```System.out.println("---- Initial Board ----\n"); // ... (prints the initial board)```

Description: Prints the initial state of the Sudoku board.

## Block 8. Solving and Printing the Solved Board:

```if (sudoku.solve()) { // ... (see next) } else { // ... (see next) }```

Description: Attempts to solve the Sudoku board and prints the result.

Printing:

• Prints the solved Sudoku board if solved.
• Prints a failure message if the Sudoku cannot be solved.

## Conclusion

In conclusion, this Java Sudoku solver exemplifies the elegance of an efficient backtracking algorithm for solving 9x9 puzzles. With a well-structured Sudoku class and a clear implementation of the backtracking approach, the code not only provides a functional solution but also serves as a valuable learning resource for algorithmic problem-solving in Java. Whether you're a Sudoku enthusiast or a programming student seeking insights into puzzle-solving strategies, this implementation offers a concise and insightful reference. The blend of simplicity and effectiveness makes it a versatile tool, and its practical application in the main method demonstrates its real-world utility. Whether you're aiming to comprehend Sudoku-solving algorithms or seeking assistance with your Java assignment, this code stands as a robust and informative solution.