Sudoku Solver, a hard leetcode problem (backtracking)

Problem is here: https://leetcode.com/problems/sudoku-solver/description/

Write a program to solve a Sudoku puzzle by filling the empty cells.

A sudoku solution must satisfy all of the following rules:

1. Each of the digits 1-9 must occur exactly once in each row.
2. Each of the digits 1-9 must occur exactly once in each column.
3. Each of the the digits 1-9 must occur exactly once in each of the 9 3x3 sub-boxes of the grid.

Empty cells are indicated by the character '.'.

A sudoku puzzle...

...and its solution numbers marked in red.

Note:

• The given board contain only digits 1-9 and the character '.'.
• You may assume that the given Sudoku puzzle will have a single unique solution.
• The given board size is always 9x9.

The solution is via backtracking with pruning. Basically it is important to understand that there is only one solution, hence the moment that you find it you should cease all further processing.
The idea is to have 3 sets of hash tables keeping track of which numbers have already been used for each row (9 hash tables), column (9 hash tables) and quadrants (9 hash tables).
The backtracking will be controlled by an index from 0..81, and with this index you should be able to access the row, the column and the quadrant. The formula for the quadrant based on the index took me the longest to figure out, but with some paper/pen/trial/error, in few minutes you can find it (actual sketch below):

First add all the current numbers to the appropriate hash tables. Then start the backtracking: if you reach the end (index == 81), you have found the solution. If the current cell contains an initial number, skip it. Otherwise, backtrack it for all numbers 1..9. Code is below, cheers, Marcelo.

public class Solution
{
 public void SolveSudoku(char[][] board)
 {
  Hashtable[] rows = new Hashtable[9];
  Hashtable[] cols = new Hashtable[9];
  Hashtable[] quadrants = new Hashtable[9];

  for (int i = 0; i < 9; i++)
  {
   rows[i] = new Hashtable();
   cols[i] = new Hashtable();
   quadrants[i] = new Hashtable();
  }

  //Add all current values to the hash tables
  int index = 0;
  for (int r = 0; r < 9; r++)
  {
   for (int c = 0; c < 9; c++)
   {
    if (board[r][c] != '.')
    {
     AddNumber(index, (int)(board[r][c] - '0'), rows, cols, quadrants);
    }
    index++;
   }
  }

  SolveSudoku(board, 0, rows, cols, quadrants);
 }

 private bool SolveSudoku(char[][] board, 
        int index,
        Hashtable[] rows,
        Hashtable[] cols,
        Hashtable[] quadrants)
 {
  if (index == 81) return true;

  int r = index / 9;
  int c = index % 9;
  if (board[r][c] != '.') return SolveSudoku(board, index + 1, rows, cols, quadrants);
  else
  {
   for (int n = 1; n <= 9; n++)
   {
    if (AddNumber(index, n, rows, cols, quadrants))
    {
     board[r][c] = (char)(n + '0');
     if (SolveSudoku(board, index + 1, rows, cols, quadrants)) return true;
     board[r][c] = '.';
     RemoveNumber(index, n, rows, cols, quadrants);
    }
   }
  }

  return false;
 }

 private bool AddNumber(int index,
       int number,
       Hashtable[] rows,
       Hashtable[] cols,
       Hashtable[] quadrants)
 {
  int r = index / 9;
  int c = index % 9;
  int q = (index / 27) * 3 + (index % 9) / 3;
  if (!rows[r].ContainsKey(number) && !cols[c].ContainsKey(number) && !quadrants[q].ContainsKey(number))
  {
   rows[r].Add(number, true);
   cols[c].Add(number, true);
   quadrants[q].Add(number, true);
   return true;
  }
  return false;
 }

 private void RemoveNumber(int index,
        int number,
        Hashtable[] rows,
        Hashtable[] cols,
        Hashtable[] quadrants)
 {
  int r = index / 9;
  int c = index % 9;
  int q = (index / 27) * 3 + (index % 9) / 3;
  rows[r].Remove(number);
  cols[c].Remove(number);
  quadrants[q].Remove(number);
 }
}