Solving Sudoku Using Multithreading in Java

Sudoku is a popular puzzle game that involves filling a 9x9 grid with numbers so that each row, each column, and each 3x3 sub-grid contain all the numbers from 1 to 9. Solving Sudoku programmatically can be challenging, but multithreading can significantly enhance the performance by leveraging parallel processing capabilities. In this section, we will discuss how to solve a Sudoku puzzle using multithreading in Java.

Understanding the Sudoku Solver

Before diving into multithreading, let's understand the basic approach to solving a Sudoku puzzle. The common method is the backtracking algorithm:

Find an empty cell: Search for the first cell that is not filled (contains a 0).

Try numbers: Attempt to place numbers from 1 to 9 in the empty cell.

Check validity: For each number, check if it is valid (i.e., not already present in the current row, column, or 3x3 sub-grid).

Recursion: If the number is valid, recursively attempt to solve the puzzle with this number in place.

Backtrack: If no number leads to a solution, reset the cell to empty and backtrack to the previous step.

Introducing Multithreading

Multithreading can be used to parallelize the backtracking process, especially for large puzzles or puzzles with multiple solutions. Here's how we can approach it:

Divide the work: Split the puzzle into independent sections that can be solved concurrently.

Thread management: Create and manage threads to solve different sections of the puzzle simultaneously.

Synchronization: Ensure that threads do not interfere with each other and that the puzzle's integrity is maintained.

Implementing Sudoku Solver in Java

Step 1: Basic Sudoku Solver

First, let's implement a basic Sudoku solver using backtracking:

 
public class SudokuSolver {
    private static final int SIZE = 9;   
    public boolean solveSudoku(int[][] board) {
        for (int row = 0; row < SIZE; row++) {
            for (int col = 0; col < SIZE; col++) {
                if (board[row][col] == 0) {
                    for (int num = 1; num <= SIZE; num++) {
                        if (isValid(board, row, col, num)) {
                            board[row][col] = num;
                            if (solveSudoku(board)) {
                                return true;
                            } else {
                                board[row][col] = 0;
                            }
                        }
                    }
                    return false;
                }
            }
        }
        return true;
    }
    private boolean isValid(int[][] board, int row, int col, int num) {
        for (int i = 0; i < SIZE; i++) {
            if (board[row][i] == num || board[i][col] == num || 
                board[row - row % 3 + i / 3][col - col % 3 + i % 3] == num) {
                return false;
            }
        }
        return true;
    }
}   

Step 2: Multithreaded Sudoku Solver

To introduce multithreading, we can create separate threads for different sections of the puzzle. Each thread will try to solve its section independently. Here is a simple implementation.

 
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class MultithreadedSudokuSolver {
    private static final int SIZE = 9;
    private static final int THREAD_COUNT = 9; // One thread per row
    public boolean solveSudoku(int[][] board) {
        ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);
        boolean[] results = new boolean[THREAD_COUNT];        
        for (int i = 0; i < THREAD_COUNT; i++) {
            final int row = i;
            executor.submit(() -> {
                results[row] = solveRow(board, row);
            });
        }        
        executor.shutdown();
        while (!executor.isTerminated()) { }        
        for (boolean result : results) {
            if (!result) {
                return false;
            }
        }
        return true;
    }   
    private boolean solveRow(int[][] board, int row) {
        for (int col = 0; col < SIZE; col++) {
            if (board[row][col] == 0) {
                for (int num = 1; num <= SIZE; num++) {
                    if (isValid(board, row, col, num)) {
                        board[row][col] = num;
                        if (solveRow(board, row)) {
                            return true;
                        } else {
                            board[row][col] = 0;
                        }
                    }
                }
                return false;
            }
        }
        return true;
    }
    private boolean isValid(int[][] board, int row, int col, int num) {
        for (int i = 0; i < SIZE; i++) {
            if (board[row][i] == num || board[i][col] == num || 
                board[row - row % 3 + i / 3][col - col % 3 + i % 3] == num) {
                return false;
            }
        }
        return true;
    }
}   

Optimizing the Multithreaded Solver

While the above example demonstrates basic multithreading, real-world scenarios require more robust and efficient designs. Here are some optimization tips:

Fine-grained parallelism: Instead of splitting by rows, consider dividing the puzzle into smaller sub-grids or even individual cells for more fine-grained parallelism.

Dynamic task allocation: Use a work-stealing algorithm or thread pool to dynamically allocate tasks to threads, ensuring better load balancing.

Thread-safe structures: Use thread-safe data structures and synchronization mechanisms (for example, ReentrantLock, CountDownLatch) to prevent race conditions and ensure data integrity.

Complete Code

Here's a complete Java program that uses multithreading to solve a Sudoku puzzle. This implementation uses Java's ExecutorService to manage threads efficiently. The program will solve a given Sudoku puzzle and print the solution.

File Name: MultithreadedSudokuSolver.java

 
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class MultithreadedSudokuSolver {
    private static final int SIZE = 9;
    private static final int SUBGRID_SIZE = 3;
    private static final int THREAD_COUNT = 9;
    public static void main(String[] args) {
        int[][] board = {
            {5, 3, 0, 0, 7, 0, 0, 0, 0},
            {6, 0, 0, 1, 9, 5, 0, 0, 0},
            {0, 9, 8, 0, 0, 0, 0, 6, 0},
            {8, 0, 0, 0, 6, 0, 0, 0, 3},
            {4, 0, 0, 8, 0, 3, 0, 0, 1},
            {7, 0, 0, 0, 2, 0, 0, 0, 6},
            {0, 6, 0, 0, 0, 0, 2, 8, 0},
            {0, 0, 0, 4, 1, 9, 0, 0, 5},
            {0, 0, 0, 0, 8, 0, 0, 7, 9}
        };
        MultithreadedSudokuSolver solver = new MultithreadedSudokuSolver();
        if (solver.solveSudoku(board)) {
            solver.printBoard(board);
        } else {
            System.out.println("No solution exists.");
        }
    }
    public boolean solveSudoku(int[][] board) {
        ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);
        Future<Boolean>[] futures = new Future[THREAD_COUNT];
        for (int i = 0; i < THREAD_COUNT; i++) {
            final int row = i;
            futures[row] = executor.submit(() -> solveRow(board, row));
        }
        executor.shutdown();
        try {
            for (Future<Boolean> future : futures) {
                if (!future.get()) {
                    return false;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
    private boolean solveRow(int[][] board, int row) {
        for (int col = 0; col < SIZE; col++) {
            if (board[row][col] == 0) {
                for (int num = 1; num <= SIZE; num++) {
                    if (isValid(board, row, col, num)) {
                        board[row][col] = num;
                        if (solveRow(board, row)) {
                            return true;
                        } else {
                            board[row][col] = 0;
                        }
                    }
                }
                return false;
            }
        }
        return true;
    }
    private boolean isValid(int[][] board, int row, int col, int num) {
        for (int i = 0; i < SIZE; i++) {
            if (board[row][i] == num || board[i][col] == num ||
                board[row - row % SUBGRID_SIZE + i / SUBGRID_SIZE][col - col % SUBGRID_SIZE + i % SUBGRID_SIZE] == num) {
                return false;
            }
        }
        return true;
    }
    private void printBoard(int[][] board) {
        for (int r = 0; r < SIZE; r++) {
            for (int d = 0; d < SIZE; d++) {
                System.out.print(board[r][d]);
                System.out.print(" ");
            }
            System.out.print("\n");
            if ((r + 1) % SUBGRID_SIZE == 0) {
                System.out.print("");
            }
        }
    }
}   

Output:

 
5 3 4 6 7 8 9 1 2 
6 7 2 1 9 5 3 4 8 
1 9 8 3 4 2 5 6 7 
8 5 9 7 6 1 4 2 3 
4 2 6 8 5 3 7 9 1 
7 1 3 9 2 4 8 5 6 
9 6 1 5 3 7 2 8 4 
2 8 7 4 1 9 6 3 5 
3 4 5 2 8 6 1 7 9

Explanation

Class and Constants: The MultithreadedSudokuSolver class contains the main logic. Constants SIZE, SUBGRID_SIZE, and THREAD_COUNT define the size of the board, subgrid, and number of threads, respectively.

main() Method: The main() method initializes a Sudoku board and attempts to solve it using the solveSudoku method. If a solution is found, it prints the board; otherwise, it prints that no solution exists.

solveSudoku() Method: Themethod uses an ExecutorService with a fixed thread pool of size THREAD_COUNT. It creates and submits a task for each row to solve it in parallel. The Future array stores the results of these tasks. It waits for all tasks to complete and returns true if all rows are successfully solved.

solveRow() Method: The method attempts to solve a single row using the backtracking algorithm. It iterates through each cell in the row, trying to place numbers from 1 to 9 and recursively solving the row. If a valid placement is found, it continues; otherwise, it backtracks.

isValid() Method: The method checks if placing a number in a specific cell is valid by ensuring that the number is not already present in the current row, column, or 3x3 subgrid.

printBoard() Method: The method prints the Sudoku board in a readable format.

Conclusion

Solving Sudoku using multithreading in Java can significantly speed up the process by leveraging the power of parallel processing. By dividing the puzzle into independent sections and managing threads efficiently, we can achieve faster and more scalable solutions. However, it's essential to balance parallelism with synchronization to maintain the integrity of the solution.

Next TopicSpiral-matrix-problem-in-java

← prev next →