Sudoku

public class Solver {

    int[][] grid        = new int[9][9];
    int[][] solution    = new int[9][9];

    int[][] colDigits   = new int[9][9];
    int[][] rowDigits   = new int[9][9];
    int[][] boxDigits   = new int[9][9];

    boolean solved      = false;

    public Solver(int[][] table) {
        solved = false;
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                if (table[i][j] != 0)
                    AssignToGrid(i, j, table[i][j]);
                grid[i][j] = table[i][j];
            }
        }
    }

    private boolean isDigitOnRow(int row, int digit) {
        return colDigits[row][digit - 1] != 0;
    }

    private boolean isDigitOnCol(int col, int digit) {
        return rowDigits[col][digit - 1] != 0;
    }

    private boolean isDigitOnBox(int box, int digit) {
        return boxDigits[box][digit - 1] != 0;
    }

    private int boxFromPosition(int row, int col) {
        return (row / 3) * 3 + col / 3;
    }

    private void AssignDigitToColumn(int digit, int col, int set) {
        rowDigits[col][digit - 1] = set;
    }

    public void AssignDigitToRow(int digit, int row, int set) {
        colDigits[row][digit - 1] = set;
    }

    public void AssignDigitToBox(int digit, int box, int set) {
        boxDigits[box][digit - 1] = set;
    }

    public void AssignToGrid(int row, int col, int digit) {
        AssignDigitToColumn(digit, col, 1);
        AssignDigitToRow(digit, row, 1);
        AssignDigitToBox(digit, boxFromPosition(row, col), 1);
    }

    public void UnassignFromGrid(int row, int col, int digit) {
        AssignDigitToColumn(digit, col, 0);
        AssignDigitToRow(digit, row, 0);
        AssignDigitToBox(digit, boxFromPosition(row, col), 0);
    }

    public boolean isDigitAssigned(int row, int col, int digit) {
        return isDigitOnRow(row, digit) || isDigitOnCol(col, digit)
            || isDigitOnBox(boxFromPosition(row, col), digit);
    }
    private void search(int row, int col) {
        if (row == 9) {
            solved = true;
            return;
        }
        if (solution[row][col] != 0) {
            if (col == 8)
                search(row + 1, 0);
            else
                search(row, col + 1);
            return;
        }
        for (int digits = 1; digits < 10; digits++) {
            if (!isDigitAssigned(row, col, digits)) {
                AssignToGrid(row, col, digits);
                if (col == 8)
                    search(row + 1, 0);
                else
                    search(row, col + 1);
                UnassignFromGrid(row, col, digits);
            }
        }
    }

    public void solve() {
        search(0, 0);
    }
}