用C++实现的数独(Sudoku)计算器

 

Licensed under The GNU General Public License v3.0

cell.h

#ifndef CELL_H_ #define CELL_H_ #pragma once #include <cassert> // class CCell { private: int m_iDigit; bool m_bIsGiven; bool m_bPossible[9]; public: CCell(void); // const method inline int GetDigit(void) const; inline bool IsGiven(void) const; inline bool IsPossible(int iDigit) const; // non-const method inline void AddPossibility(int iDigit); void OnCreate(void); inline void RemovePossibility(int iDigit); inline void SetDigit(int iDigit); inline void SetGivenDigit(int iDigit); inline void UnsetDigit(void); }; // inline void CCell::AddPossibility(int iDigit) { assert(1 <= iDigit && iDigit <= 9); assert(!m_bIsGiven); m_bPossible[iDigit - 1] = true; assert(IsPossible(iDigit)); } // inline int CCell::GetDigit(void) const { return m_iDigit; } // inline bool CCell::IsGiven(void) const { return m_bIsGiven; } // inline bool CCell::IsPossible(int iDigit) const { assert(1 <= iDigit && iDigit <= 9); assert(!m_bIsGiven); return m_bPossible[iDigit - 1]; } // inline void CCell::RemovePossibility(int iDigit) { assert(1 <= iDigit && iDigit <= 9); assert(m_iDigit != iDigit); m_bPossible[iDigit - 1] = false; assert(!IsPossible(iDigit)); } // inline void CCell::SetDigit(int iDigit) { assert(1 <= iDigit && iDigit <= 9); assert(!m_bIsGiven); assert(!m_iDigit); assert(IsPossible(iDigit)); m_iDigit = iDigit; assert(GetDigit() == iDigit); } // inline void CCell::SetGivenDigit(int iDigit) { assert(1 <= iDigit && iDigit <= 9); assert(!m_bIsGiven); assert(!m_iDigit); assert(IsPossible(iDigit)); m_iDigit = iDigit; m_bIsGiven = true; assert(IsGiven()); assert(GetDigit() == iDigit); } // inline void CCell::UnsetDigit(void) { assert(!m_bIsGiven); assert(m_iDigit); m_iDigit = 0; assert(!GetDigit()); } #endif /* CELL_H_ */

cell.cpp

#include "cell.h" // CCell::CCell(void) : m_iDigit(0), m_bIsGiven(false) { for (int i = 0; i < 9; ++i) { m_bPossible[i] = true; } } // void CCell::OnCreate(void) { m_iDigit = 0; m_bIsGiven = false; for (int i = 0; i < 9; ++i) { m_bPossible[i] = true; } }

grid.h

#ifndef GRID_H_ #define GRID_H_ #pragma once #include <cassert> #include "cell.h" // struct CStep { public: int m_iCol; int m_iDigit; int m_iRow; public: inline CStep(void); // non-const method inline void OnCreate(void); }; // class CGrid { private: int m_iStepCount; bool m_bBoxHasDigit[9][9]; bool m_bColHasDigit[9][9]; bool m_bRowHasDigit[9][9]; CCell m_cells[9][9]; CStep m_steps[82]; private: // non-const method void PrepareSteps(void); void OnCreate(void); void UpdatePossibilityFor(int iRow, int iCol); // static method inline static int GetBoxIndex(int iRow, int iCol); public: CGrid(void); // const method inline int GetDigit(int iRow, int iCol) const; inline bool HasBoxDigit(int iRow, int iCol, int iDigit) const; inline bool HasColDigit(int iCol, int iDigit) const; inline bool HasRowDigit(int iRow, int iDigit) const; inline bool IsGiven(int iRow, int iCol) const; inline bool IsPossible(int iRow, int iCol, int iDigit) const; // non-const method inline void AddPossibility(int iRow, int iCol, int iDigit); bool CalcFromCurrent(void); bool CalcFromLastSolution(void); inline void RemovePossibility(int iRow, int iCol, int iDigit); inline void SetDigit(int iRow, int iCol, int iDigit); bool SetGivenDigit(const char *pszDigits); inline void SetGivenDigit(int iRow, int iCol, int iDigit); inline void UnsetDigit(int iRow, int iCol); }; // inline CStep::CStep(void) : m_iCol(0), m_iDigit(0), m_iRow(0) { } // inline void CStep::OnCreate(void) { m_iCol = 0; m_iDigit = 0; m_iRow = 0; } // inline void CGrid::AddPossibility(int iRow, int iCol, int iDigit) { assert(1 <= iRow && iRow <= 9); assert(1 <= iCol && iCol <= 9); assert(1 <= iDigit && iDigit <= 9); m_cells[iRow - 1][iCol - 1].AddPossibility(iDigit); assert(IsPossible(iRow, iCol, iDigit)); } // inline int CGrid::GetBoxIndex(int iRow, int iCol) { assert(1 <= iRow && iRow <= 9); assert(1 <= iCol && iCol <= 9); return (iRow - 1) / 3 * 3 + (iCol - 1) / 3; } // inline int CGrid::GetDigit(int iRow, int iCol) const { assert(1 <= iRow && iRow <= 9); assert(1 <= iCol && iCol <= 9); return m_cells[iRow - 1][iCol - 1].GetDigit(); } // inline bool CGrid::HasBoxDigit(int iRow, int iCol, int iDigit) const { assert(1 <= iRow && iRow <= 9); assert(1 <= iCol && iCol <= 9); assert(1 <= iDigit && iDigit <= 9); return m_bBoxHasDigit[GetBoxIndex(iRow, iCol)][iDigit - 1]; } // inline bool CGrid::HasColDigit(int iCol, int iDigit) const { assert(1 <= iCol && iCol <= 9); assert(1 <= iDigit && iDigit <= 9); return m_bColHasDigit[iCol - 1][iDigit - 1]; } // inline bool CGrid::HasRowDigit(int iRow, int iDigit) const { assert(1 <= iRow && iRow <= 9); assert(1 <= iDigit && iDigit <= 9); return m_bRowHasDigit[iRow - 1][iDigit - 1]; } // inline bool CGrid::IsGiven(int iRow, int iCol) const { assert(1 <= iRow && iRow <= 9); assert(1 <= iCol && iCol <= 9); return m_cells[iRow - 1][iCol - 1].IsGiven(); } // inline bool CGrid::IsPossible(int iRow, int iCol, int iDigit) const { assert(1 <= iRow && iRow <= 9); assert(1 <= iCol && iCol <= 9); assert(1 <= iDigit && iDigit <= 9); if (GetDigit(iRow, iCol) == iDigit) { return true; } if (HasRowDigit(iRow, iDigit) || HasColDigit(iCol, iDigit) || HasBoxDigit(iRow, iCol, iDigit)) { return false; } return m_cells[iRow - 1][iCol - 1].IsPossible(iDigit); } // inline void CGrid::RemovePossibility(int iRow, int iCol, int iDigit) { assert(1 <= iRow && iRow <= 9); assert(1 <= iCol && iCol <= 9); assert(1 <= iDigit && iDigit <= 9); assert(GetDigit(iRow, iCol) != iDigit); m_cells[iRow - 1][iCol - 1].RemovePossibility(iDigit); assert(!IsPossible(iRow, iCol, iDigit)); } // inline void CGrid::SetDigit(int iRow, int iCol, int iDigit) { assert(1 <= iRow && iRow <= 9); assert(1 <= iCol && iCol <= 9); assert(1 <= iDigit && iDigit <= 9); assert(IsPossible(iRow, iCol, iDigit)); assert(!GetDigit(iRow, iCol)); m_cells[iRow - 1][iCol - 1].SetDigit(iDigit); m_bBoxHasDigit[GetBoxIndex(iRow, iCol)][iDigit - 1] = true; m_bRowHasDigit[iRow - 1][iDigit - 1] = true; m_bColHasDigit[iCol - 1][iDigit - 1] = true; assert(GetDigit(iRow, iCol) == iDigit); } // inline void CGrid::SetGivenDigit(int iRow, int iCol, int iDigit) { assert(1 <= iRow && iRow <= 9); assert(1 <= iCol && iCol <= 9); assert(1 <= iDigit && iDigit <= 9); assert(IsPossible(iRow, iCol, iDigit)); assert(!GetDigit(iRow, iCol)); m_cells[iRow - 1][iCol - 1].SetGivenDigit(iDigit); m_bBoxHasDigit[GetBoxIndex(iRow, iCol)][iDigit - 1] = true; m_bRowHasDigit[iRow - 1][iDigit - 1] = true; m_bColHasDigit[iCol - 1][iDigit - 1] = true; assert(IsGiven(iRow, iCol)); assert(GetDigit(iRow, iCol) == iDigit); } // inline void CGrid::UnsetDigit(int iRow, int iCol) { assert(1 <= iRow && iRow <= 9); assert(1 <= iCol && iCol <= 9); assert(!IsGiven(iRow, iCol)); int iDigit; iDigit = GetDigit(iRow, iCol); assert(1 <= iDigit && iDigit <= 9); m_cells[iRow - 1][iCol - 1].UnsetDigit(); m_bBoxHasDigit[GetBoxIndex(iRow, iCol)][iDigit - 1] = false; m_bRowHasDigit[iRow - 1][iDigit - 1] = false; m_bColHasDigit[iCol - 1][iDigit - 1] = false; assert(!GetDigit(iRow, iCol)); assert(!HasBoxDigit(iRow, iCol, iDigit)); assert(!HasColDigit(iCol, iDigit)); assert(!HasRowDigit(iRow, iDigit)); } #endif /* GRID_H_ */

grid.cpp

#include "grid.h" // CGrid::CGrid(void) : m_iStepCount(0) { for (int i = 0; i < 9; ++i) { for (int j = 0; j < 9; ++j) { m_bBoxHasDigit[i][j] = false; m_bColHasDigit[i][j] = false; m_bRowHasDigit[i][j] = false; } } } // bool CGrid::CalcFromCurrent(void) { int i; int r, c, d; PrepareSteps(); for (i = 0; m_steps[i].m_iRow; ++i) { r = m_steps[i].m_iRow; c = m_steps[i].m_iCol; assert(!GetDigit(r, c)); d = 1; while (d <= 9) { if (IsPossible(r, c, d)) { SetDigit(r, c, d); m_steps[i].m_iDigit = d; break; } ++d; while (d > 9) { do { if (i <= 0) { return false; } CStep &step = m_steps[--i]; r = step.m_iRow; c = step.m_iCol; d = step.m_iDigit + 1; step.m_iDigit = 0; UnsetDigit(r, c); } while (r >= 9 || (r >= 7 && c >= 7) || c >= 9); } } } m_iStepCount = i; return (m_iStepCount > 0) || (!m_steps[0].m_iRow); } // bool CGrid::CalcFromLastSolution(void) { int i; int r, c, d; i = m_iStepCount; do { if (i <= 0) { m_iStepCount = i; return false; } CStep &step = m_steps[--i]; r = step.m_iRow; c = step.m_iCol; d = step.m_iDigit + 1; step.m_iDigit = 0; UnsetDigit(r, c); } while (r >= 9 || (r >= 7 && c >= 7) || c >= 9 || d > 9); for (; m_steps[i].m_iRow; ++i) { r = m_steps[i].m_iRow; c = m_steps[i].m_iCol; assert(!GetDigit(r, c)); while (d <= 9) { if (IsPossible(r, c, d)) { SetDigit(r, c, d); m_steps[i].m_iDigit = d; d = 1; break; } ++d; while (d > 9) { do { if (i <= 0) { m_iStepCount = i; return false; } CStep &step = m_steps[--i]; r = step.m_iRow; c = step.m_iCol; d = step.m_iDigit + 1; step.m_iDigit = 0; UnsetDigit(r, c); } while (r >= 9 || (r >= 7 && c >= 7) || c >= 9); } } } m_iStepCount = i; return (m_iStepCount > 0); } // void CGrid::OnCreate(void) { unsigned int i, j; m_iStepCount = 0; for (i = 0; i < 9; ++i) { for (j = 0; j < 9; ++j) { m_bBoxHasDigit[i][j] = false; m_bColHasDigit[i][j] = false; m_bRowHasDigit[i][j] = false; m_cells[i][j].OnCreate(); } } for (i = 0; i < sizeof(m_steps) / sizeof(m_steps[0]); ++i) { m_steps[i].OnCreate(); } } // void CGrid::PrepareSteps(void) { int r, c; unsigned int i; i = 0; for (r = 1; r <= 9; ++r) { for (c = 1; c <= 9; ++c) { if (!GetDigit(r, c)) { CStep &step = m_steps[i++]; step.m_iCol = c; step.m_iRow = r; step.m_iDigit = 0; } } } for (; i < sizeof(m_steps) / sizeof(m_steps[0]); ++i) { m_steps[i].OnCreate(); } } // bool CGrid::SetGivenDigit(const char *pszDigits) { assert(pszDigits); bool bOK; const char *pDigit; unsigned int iCellIndex; OnCreate(); bOK = true; iCellIndex = 0; for (pDigit = pszDigits; *pDigit; ++pDigit) { if (*pDigit == '0') { ++iCellIndex; } else if ('1' <= *pDigit && *pDigit <= '9') { if (iCellIndex >= sizeof(m_cells) / sizeof(CCell)) { return false; } int iRow, iCol, iDigit; iRow = iCellIndex / 9 + 1; iCol = iCellIndex % 9 + 1; iDigit = *pDigit - '0'; if (IsPossible(iRow, iCol, iDigit)) { SetGivenDigit(iRow, iCol, iDigit); } else { bOK = false; } ++iCellIndex; } } return bOK; } // void CGrid::UpdatePossibilityFor(int iRow, int iCol) { assert(1 <= iRow && iRow <= 9); assert(1 <= iCol && iCol <= 9); int iDigit; iDigit = GetDigit(iRow, iCol); assert(1 <= iDigit && iDigit <= 9); int i, j; int startx, starty, endx, endy; // remove possibility of the cells in the same box startx = (iRow - 1) / 3 * 3 + 1; starty = (iCol - 1) / 3 * 3 + 1; endx = startx + 2; endy = starty + 2; for (i = startx; i <= endx; ++i) { for (j = starty; j <= endy; ++j) { if (i != iRow || j != iCol) { m_cells[i - 1][j - 1].RemovePossibility(iDigit); } } } // remove possibility of the cells in the same row for (i = 0; i < startx - 1; ++i) { m_cells[i][iCol - 1].RemovePossibility(iDigit); } for (i = endx; i < 9; ++i) { m_cells[i][iCol - 1].RemovePossibility(iDigit); } // remove possibility of the cells in the same column for (i = 0; i < starty - 1; ++i) { m_cells[iRow - 1][i].RemovePossibility(iDigit); } for (i = endy; i < 9; ++i) { m_cells[iRow - 1][i].RemovePossibility(iDigit); } }

 

TopRowGrid.h

#ifndef TOPROWGRID_H_ #define TOPROWGRID_H_ #pragma once #include <cassert> #include <string> #include "grid.h" // class CTopRowGrid { private: int m_iStepCount; bool m_bBoxHasDigit[3][9]; bool m_bColHasDigit[9][9]; bool m_bRowHasDigit[3][9]; CCell m_cells[3][9]; CStep m_steps[28]; private: // const method inline int GetDigit(int iRow, int iCol) const; inline bool HasBoxDigit(int iRow, int iCol, int iDigit) const; inline bool HasColDigit(int iCol, int iDigit) const; inline bool HasRowDigit(int iRow, int iDigit) const; inline bool IsGiven(int iRow, int iCol) const; inline bool IsPossible(int iRow, int iCol, int iDigit) const; // non-const method void OnCreate(void); void PrepareSteps(void); inline void SetDigit(int iRow, int iCol, int iDigit); inline void SetGivenDigit(int iRow, int iCol, int iDigit); inline void UnsetDigit(int iRow, int iCol); // static method inline static int GetBoxIndex(int iRow, int iCol); public: CTopRowGrid(void); // const method std::string GetKeyString(void) const; // non-const method bool CalcFromCurrent(void); bool CalcFromLastSolution(void); bool SetGivenDigit(const char *pszDigits); }; // inline int CTopRowGrid::GetBoxIndex(int iRow, int iCol) { assert(1 <= iRow && iRow <= 3); assert(1 <= iCol && iCol <= 9); return (iRow - 1) / 3 * 3 + (iCol - 1) / 3; } // inline int CTopRowGrid::GetDigit(int iRow, int iCol) const { assert(1 <= iRow && iRow <= 3); assert(1 <= iCol && iCol <= 9); return m_cells[iRow - 1][iCol - 1].GetDigit(); } // inline bool CTopRowGrid::HasBoxDigit(int iRow, int iCol, int iDigit) const { assert(1 <= iRow && iRow <= 3); assert(1 <= iCol && iCol <= 9); assert(1 <= iDigit && iDigit <= 9); return m_bBoxHasDigit[GetBoxIndex(iRow, iCol)][iDigit - 1]; } // inline bool CTopRowGrid::HasColDigit(int iCol, int iDigit) const { assert(1 <= iCol && iCol <= 9); assert(1 <= iDigit && iDigit <= 9); return m_bColHasDigit[iCol - 1][iDigit - 1]; } // inline bool CTopRowGrid::HasRowDigit(int iRow, int iDigit) const { assert(1 <= iRow && iRow <= 3); assert(1 <= iDigit && iDigit <= 9); return m_bRowHasDigit[iRow - 1][iDigit - 1]; } // inline bool CTopRowGrid::IsGiven(int iRow, int iCol) const { assert(1 <= iRow && iRow <= 3); assert(1 <= iCol && iCol <= 9); return m_cells[iRow - 1][iCol - 1].IsGiven(); } // inline bool CTopRowGrid::IsPossible(int iRow, int iCol, int iDigit) const { assert(1 <= iRow && iRow <= 3); assert(1 <= iCol && iCol <= 9); assert(1 <= iDigit && iDigit <= 9); if (GetDigit(iRow, iCol) == iDigit) { return true; } if (HasRowDigit(iRow, iDigit) || HasColDigit(iCol, iDigit) || HasBoxDigit(iRow, iCol, iDigit)) { return false; } if (iRow == 1) { switch (iCol) { case 9: if (GetDigit(1, 8) >= iDigit) { return false; } break; case 8: if (GetDigit(1, 7) >= iDigit) { return false; } break; case 7: if (iDigit > 7) { return false; } break; case 6: if (GetDigit(1, 5) >= iDigit) { return false; } break; case 5: if (GetDigit(1, 4) >= iDigit) { return false; } break; } } return m_cells[iRow - 1][iCol - 1].IsPossible(iDigit); } // inline void CTopRowGrid::SetDigit(int iRow, int iCol, int iDigit) { assert(1 <= iRow && iRow <= 3); assert(1 <= iCol && iCol <= 9); assert(1 <= iDigit && iDigit <= 9); assert(IsPossible(iRow, iCol, iDigit)); assert(!GetDigit(iRow, iCol)); m_cells[iRow - 1][iCol - 1].SetDigit(iDigit); m_bBoxHasDigit[GetBoxIndex(iRow, iCol)][iDigit - 1] = true; m_bRowHasDigit[iRow - 1][iDigit - 1] = true; m_bColHasDigit[iCol - 1][iDigit - 1] = true; assert(GetDigit(iRow, iCol) == iDigit); } // inline void CTopRowGrid::SetGivenDigit(int iRow, int iCol, int iDigit) { assert(1 <= iRow && iRow <= 3); assert(1 <= iCol && iCol <= 9); assert(1 <= iDigit && iDigit <= 9); assert(IsPossible(iRow, iCol, iDigit)); assert(!GetDigit(iRow, iCol)); m_cells[iRow - 1][iCol - 1].SetGivenDigit(iDigit); m_bBoxHasDigit[GetBoxIndex(iRow, iCol)][iDigit - 1] = true; m_bRowHasDigit[iRow - 1][iDigit - 1] = true; m_bColHasDigit[iCol - 1][iDigit - 1] = true; assert(IsGiven(iRow, iCol)); assert(GetDigit(iRow, iCol) == iDigit); } // inline void CTopRowGrid::UnsetDigit(int iRow, int iCol) { assert(1 <= iRow && iRow <= 3); assert(1 <= iCol && iCol <= 9); assert(!IsGiven(iRow, iCol)); int iDigit; iDigit = GetDigit(iRow, iCol); assert(1 <= iDigit && iDigit <= 9); m_cells[iRow - 1][iCol - 1].UnsetDigit(); m_bBoxHasDigit[GetBoxIndex(iRow, iCol)][iDigit - 1] = false; m_bRowHasDigit[iRow - 1][iDigit - 1] = false; m_bColHasDigit[iCol - 1][iDigit - 1] = false; assert(!GetDigit(iRow, iCol)); assert(!HasBoxDigit(iRow, iCol, iDigit)); assert(!HasColDigit(iCol, iDigit)); assert(!HasRowDigit(iRow, iDigit)); } #endif /* TOPROWGRID_H_ */

TopRowGrid.cpp

#include <cassert> #include "TopRowGrid.h" // CTopRowGrid::CTopRowGrid(void) : m_iStepCount(0) { int i, j; for (i = 0; i < 3; ++i) { for (j = 0; j < 9; ++j) { m_bBoxHasDigit[i][j] = false; m_bRowHasDigit[i][j] = false; } } for (i = 0; i < 9; ++i) { for (j = 0; j < 9; ++j) { m_bColHasDigit[i][j] = false; } } } // bool CTopRowGrid::CalcFromCurrent(void) { int i; int r, c, d; PrepareSteps(); for (i = 0; m_steps[i].m_iRow; ++i) { r = m_steps[i].m_iRow; c = m_steps[i].m_iCol; assert(!GetDigit(r, c)); d = 1; while (d <= 9) { if (IsPossible(r, c, d)) { SetDigit(r, c, d); m_steps[i].m_iDigit = d; break; } ++d; while (d > 9) { do { if (i <= 0) { return false; } CStep &step = m_steps[--i]; r = step.m_iRow; c = step.m_iCol; d = step.m_iDigit + 1; step.m_iDigit = 0; UnsetDigit(r, c); } while (c >= 9); } } } m_iStepCount = i; return (m_iStepCount > 0) || (!m_steps[0].m_iRow); } // bool CTopRowGrid::CalcFromLastSolution(void) { int i; int r, c, d; i = m_iStepCount; do { if (i <= 0) { m_iStepCount = i; return false; } CStep &step = m_steps[--i]; r = step.m_iRow; c = step.m_iCol; d = step.m_iDigit + 1; step.m_iDigit = 0; UnsetDigit(r, c); } while (c >= 9 || d > 9); for (; m_steps[i].m_iRow; ++i) { r = m_steps[i].m_iRow; c = m_steps[i].m_iCol; assert(!GetDigit(r, c)); while (d <= 9) { if (IsPossible(r, c, d)) { SetDigit(r, c, d); m_steps[i].m_iDigit = d; d = 1; break; } ++d; while (d > 9) { do { if (i <= 0) { m_iStepCount = i; return false; } CStep &step = m_steps[--i]; r = step.m_iRow; c = step.m_iCol; d = step.m_iDigit + 1; step.m_iDigit = 0; UnsetDigit(r, c); } while (c >= 9); } } } m_iStepCount = i; return (m_iStepCount > 0); } // std::string CTopRowGrid::GetKeyString(void) const { std::string str; for (int r = 1; r <= 3; ++r) { for (int c = 1; c <= 9; ++c) { str += '0' + GetDigit(r, c); } } return str; } // void CTopRowGrid::OnCreate(void) { unsigned int i, j; m_iStepCount = 0; for (i = 0; i < 3; ++i) { for (j = 0; j < 9; ++j) { m_bBoxHasDigit[i][j] = false; m_bRowHasDigit[i][j] = false; m_cells[i][j].OnCreate(); } } for (i = 0; i < 9; ++i) { for (j = 0; j < 9; ++j) { m_bColHasDigit[i][j] = false; } } for (i = 0; i < sizeof(m_steps) / sizeof(m_steps[0]); ++i) { m_steps[i].OnCreate(); } } // void CTopRowGrid::PrepareSteps(void) { int r, c; unsigned int i; i = 0; for (r = 1; r <= 3; ++r) { for (c = 1; c <= 9; ++c) { if (!GetDigit(r, c)) { CStep &step = m_steps[i++]; step.m_iCol = c; step.m_iRow = r; step.m_iDigit = 0; } } } for (; i < sizeof(m_steps) / sizeof(m_steps[0]); ++i) { m_steps[i].OnCreate(); } } // bool CTopRowGrid::SetGivenDigit(const char *pszDigits) { assert(pszDigits); bool bOK; const char *pDigit; unsigned int iCellIndex; OnCreate(); bOK = true; iCellIndex = 0; for (pDigit = pszDigits; *pDigit; ++pDigit) { if (*pDigit == '0') { ++iCellIndex; } else if ('1' <= *pDigit && *pDigit <= '9') { if (iCellIndex >= sizeof(m_cells) / sizeof(CCell)) { return false; } int iRow, iCol, iDigit; iRow = iCellIndex / 9 + 1; iCol = iCellIndex % 9 + 1; iDigit = *pDigit - '0'; if (IsPossible(iRow, iCol, iDigit)) { SetGivenDigit(iRow, iCol, iDigit); } else { bOK = false; } ++iCellIndex; } } return bOK; }

sudoku.cpp

//============================================================================ // Name : sudoku.cpp // Author : Feiyun Wang (feiyunw@yahoo.com) // Version : // Copyright : Copyright(C) 2010-2011. All rights reserved. // Description : Sudoku solver //============================================================================ #include <algorithm> #include <cassert> #include <ctime> #include <iostream> #include <map> #include <boost/program_options.hpp> #include <boost/thread.hpp> #include "TopRowGrid.h" namespace po = boost::program_options; // __int64 GetSolutionCount(const CGrid &grid, __int64 *pCount) { CGrid g(grid); __int64 iSolution; iSolution = 0; if (g.CalcFromCurrent()) { ++iSolution; while (g.CalcFromLastSolution()) { ++iSolution; } } if (pCount) { *pCount = iSolution; } return iSolution; } // void PrintGrid(const CGrid &grid) { int i, j, k; std::cout << "---+---+---" << std::endl; for (i = 1; i <= 9; ++i) { for (j = 1; j <= 9; ++j) { k = grid.GetDigit(i, j); if (k) { std::cout << k; } else { std::cout << '.'; } if (j == 3 || j == 6) { std::cout << ' '; } } std::cout << std::endl; if (i == 3 || i == 6) { std::cout << " + +" << std::endl; } } } // void Solve(const char *pProblem) { assert(pProblem); CGrid grid; __int64 iSolution; clock_t tBegin; tBegin = clock(); if (!grid.SetGivenDigit(pProblem)) { std::cout << "There is an error in the given numbers!" << std::endl; } PrintGrid(grid); iSolution = 0; if (grid.CalcFromCurrent()) { std::cout << (clock() - tBegin) / double(CLOCKS_PER_SEC) << " seconds has elapsed for the first solution." << std::endl; ++iSolution; PrintGrid(grid); while (grid.CalcFromLastSolution()) { ++iSolution; if (iSolution >> 20 << 20 == iSolution) { std::cout << "Found " << iSolution << " solutions in " << (clock() - tBegin) / double( CLOCKS_PER_SEC) << " seconds." << std::endl; } } } std::cout << (clock() - tBegin) / double(CLOCKS_PER_SEC) << " seconds has elapsed. "; if (iSolution > 1) { std::cout << "Found total " << iSolution << " solutions. " << std::endl; } else if (iSolution == 1) { std::cout << "Found total 1 solution." << std::endl; } else { std::cout << "No solution!" << std::endl; } } // inline void SwapBlock(std::string &str, int iStep) { assert(0 <= iStep && iStep <= 5); const std::string oldStr = str; switch (iStep) { case 0: // no swap break; case 1: case 3: case 5: // swap block 1 and 2 str.replace(0, 3, oldStr, 3, 3); str.replace(3, 3, oldStr, 0, 3); str.replace(9, 3, oldStr, 12, 3); str.replace(12, 3, oldStr, 9, 3); str.replace(18, 3, oldStr, 21, 3); str.replace(21, 3, oldStr, 18, 3); break; case 2: case 4: // swap block 2 and 3 str.replace(3, 3, oldStr, 6, 3); str.replace(6, 3, oldStr, 3, 3); str.replace(12, 3, oldStr, 15, 3); str.replace(15, 3, oldStr, 12, 3); str.replace(21, 3, oldStr, 24, 3); str.replace(24, 3, oldStr, 21, 3); break; } } // inline void SwapColumn(std::string &str, int iBlock, int iStep) { assert(1 <= iBlock && iBlock <= 3); assert(0 <= iStep && iStep <= 5); int c1, c2; char c; switch (iStep) { case 0: // no swap break; case 1: case 3: case 5: // swap column 1 and 2 c1 = (iBlock - 1) * 3; c2 = c1 + 1; c = str[c1]; str[c1] = str[c2]; str[c2] = c; c1 += 9; c2 = c1 + 1; c = str[c1]; str[c1] = str[c2]; str[c2] = c; c1 += 9; c2 = c1 + 1; c = str[c1]; str[c1] = str[c2]; str[c2] = c; break; case 2: case 4: // swap column 2 and 3 c1 = (iBlock - 1) * 3 + 1; c2 = c1 + 1; c = str[c1]; str[c1] = str[c2]; str[c2] = c; c1 += 9; c2 = c1 + 1; c = str[c1]; str[c1] = str[c2]; str[c2] = c; c1 += 9; c2 = c1 + 1; c = str[c1]; str[c1] = str[c2]; str[c2] = c; break; } } // bool SwapRow(std::string &str, int iColumn, int iStep) { assert(1 <= iColumn && iColumn <=9); assert(0 <= iStep && iStep <= 5); int r1, r2, i; char c; switch (iStep) { case 0: // no swap break; case 1: case 3: case 5: // swap row 1 and 2 r1 = iColumn - 1; r2 = r1 + 9; c = str[r1]; str[r1] = str[r2]; str[r2] = c; break; case 2: case 4: // swap row 2 and 3 r1 = iColumn - 1 + 9; r2 = r1 + 9; c = str[r1]; str[r1] = str[r2]; str[r2] = c; break; } for (i = 0; i < (iColumn - 1) / 3 * 3; ++i) { if (str[i] == str[iColumn - 1]) { return false; } if (str[i + 9] == str[iColumn - 1 + 9]) { return false; } if (str[i + 18] == str[iColumn - 1 + 18]) { return false; } } return true; } // void Normalize(std::string &str) { char trans[9]; trans[str[0] - '1'] = '1'; trans[str[1] - '1'] = '2'; trans[str[2] - '1'] = '3'; trans[str[9] - '1'] = '4'; trans[str[10] - '1'] = '5'; trans[str[11] - '1'] = '6'; trans[str[18] - '1'] = '7'; trans[str[19] - '1'] = '8'; trans[str[20] - '1'] = '9'; for (std::string::iterator it = str.begin(); it != str.end(); ++it) { *it = trans[(*it) - '1']; } if (str[3] > str[4]) { SwapColumn(str, 2, 1); } if (str[4] > str[5]) { SwapColumn(str, 2, 2); if (str[3] > str[4]) { SwapColumn(str, 2, 1); } } if (str[6] > str[7]) { SwapColumn(str, 3, 1); } if (str[7] > str[8]) { SwapColumn(str, 3, 2); if (str[6] > str[7]) { SwapColumn(str, 3, 1); } } if (str[3] > str[6]) { SwapBlock(str, 2); } } // void Enumerate(unsigned int iClassToSkip, unsigned int iJobs) { clock_t tBegin; CTopRowGrid topRowGrid; std::map<std::string, int> mapCount; // calculate possibilities for the top row of blocks tBegin = clock(); topRowGrid.SetGivenDigit("123400000456000000789"); if (topRowGrid.CalcFromCurrent()) { mapCount[topRowGrid.GetKeyString()] = 1; while (topRowGrid.CalcFromLastSolution()) { mapCount[topRowGrid.GetKeyString()] = 1; } } std::cout << (clock() - tBegin) / double(CLOCKS_PER_SEC) << " seconds has elapsed." << std::endl; std::cout << "Found total " << mapCount.size() << " possibilities for the top row of blocks, with the fixed top left block (B1) and lexicographical reduced B2 and B3." << std::endl << std::endl; std::map<std::string, int>::iterator it, it2; std::map<std::string, std::string> mapErased; std::map<std::string, std::string>::iterator itErased; // refined column permutation and relabeling for (it = mapCount.begin(); it != mapCount.end(); ++it) { std::string str1 = it->first; for (int s1 = 0; s1 < 6; ++s1) { SwapColumn(str1, 1, s1); std::string str2 = str1; for (int s2 = 0; s2 < 6; ++s2) { SwapColumn(str2, 2, s2); std::string str3 = str2; for (int s3 = 0; s3 < 6; ++s3) { SwapColumn(str3, 3, s3); std::string str4 = str3; for (int s4 = 0; s4 < 6; ++s4) { SwapBlock(str4, s4); std::string str = str4; Normalize(str); itErased = mapErased.find(str); while (itErased != mapErased.end()) { str = itErased->second; itErased = mapErased.find(str); } if (str == it->first) { continue; } it2 = mapCount.find(str); assert(it2 != mapCount.end()); it->second += it2->second; mapErased[str] = it->first; mapCount.erase(it2); } } } } } __int64 iSolution; iSolution = 0; for (it = mapCount.begin(); it != mapCount.end(); ++it) { iSolution += it->second; } // output equivalence classes std::cout << (clock() - tBegin) / double(CLOCKS_PER_SEC) << " seconds has elapsed." << std::endl; std::cout << "Found total " << iSolution << " possibilities as " << mapCount.size() << " equivalence classes, after refined column permutation and relabeling." << std::endl; std::cout << std::endl; // refined row permutation and relabeling for (it = mapCount.begin(); it != mapCount.end(); ++it) { std::string str1 = it->first; for (int s1 = 0; s1 < 6; ++s1) { SwapRow(str1, 1, s1); std::string str2 = str1; for (int s2 = 0; s2 < 6; ++s2) { SwapRow(str2, 2, s2); std::string str3 = str2; for (int s3 = 0; s3 < 6; ++s3) { SwapRow(str3, 3, s3); std::string str4 = str3; for (int s4 = 0; s4 < 6; ++s4) { if (!SwapRow(str4, 4, s4)) { continue; } std::string str5 = str4; for (int s5 = 0; s5 < 6; ++s5) { if (!SwapRow(str5, 5, s5)) { continue; } std::string str6 = str5; for (int s6 = 0; s6 < 6; ++s6) { if (!SwapRow(str6, 6, s6)) { continue; } std::string str7 = str6; for (int s7 = 0; s7 < 6; ++s7) { if (!SwapRow(str7, 7, s7)) { continue; } std::string str8 = str7; for (int s8 = 0; s8 < 6; ++s8) { if (!SwapRow(str8, 8, s8)) { continue; } std::string str9 = str8; for (int s9 = 0; s9 < 6; ++s9) { if (!SwapRow(str9, 9, s9)) { continue; } std::string str = str9; Normalize(str); itErased = mapErased.find(str); while (itErased != mapErased.end()) { str = itErased->second; itErased = mapErased.find(str); } it2 = mapCount.find(str); assert(it2 != mapCount.end()); if (it2 == it) { continue; } it->second += it2->second; mapErased[str] = it->first; mapCount.erase(it2); } } } } } } } } } } iSolution = 0; for (it = mapCount.begin(); it != mapCount.end(); ++it) { iSolution += it->second; } unsigned int iClassIndex; // output equivalence classes std::cout << (clock() - tBegin) / double(CLOCKS_PER_SEC) << " seconds has elapsed." << std::endl; std::cout << "Found total " << iSolution << " possibilities as " << mapCount.size() << " equivalence classes, after refined row permutation and relabeling." << std::endl; std::cout << "The list of a representative and the size of each equivalence class:" << std::endl; iClassIndex = 0; for (it = mapCount.begin(); it != mapCount.end(); ++it) { std::cout << "Class " << ++iClassIndex << ": " << it->first << " " << it->second << std::endl; } std::cout << std::endl; unsigned int iThreadLimit; // for multi-threading computing if (!iJobs) { iThreadLimit = boost::thread::hardware_concurrency(); if (iThreadLimit <= 0) { iThreadLimit = 1; } } else { iThreadLimit = iJobs; } int c1[10][5] = { { 3, 5, 6, 8, 9, }, { 3, 6, 5, 8, 9, }, { 3, 8, 5, 6, 9, }, { 3, 9, 5, 6, 8, }, { 5, 6, 3, 8, 9, }, { 5, 8, 3, 6, 9, }, { 5, 9, 3, 6, 8, }, { 6, 8, 3, 5, 9, }, { 6, 9, 3, 5, 8, }, { 8, 9, 3, 5, 6, }, }; CGrid grid, g2; __int64 ret[10]; unsigned int i, j; unsigned int iJoined; boost::thread threads[10]; std::map<std::string, __int64> mapSolution; std::cout << "Count solutions for each equivalence class." << std::endl; iClassIndex = 0; for (it = mapCount.begin(); it != mapCount.end(); ++it) { if (++iClassIndex <= iClassToSkip) { continue; } std::cout << "Class " << iClassIndex << ":"; tBegin = clock(); grid.SetGivenDigit(it->first.c_str()); grid.SetGivenDigit(4, 1, 2); iJoined = 0; for (i = 0; i < 10; ++i) { g2 = grid; for (j = 0; j < 5; ++j) { g2.SetGivenDigit(j + 5, 1, c1[i][j]); } threads[i] = boost::thread(GetSolutionCount, g2, &ret[i]); if (i + 1 >= iThreadLimit + iJoined) { threads[iJoined].join(); std::cout << '.'; ++iJoined; } } for (; iJoined < 10; ++iJoined) { threads[iJoined].join(); std::cout << '.'; } iSolution = 0; for (i = 0; i < 10; ++i) { iSolution += ret[i]; } mapSolution[it->first] = iSolution; std::cout << (clock() - tBegin) / double(CLOCKS_PER_SEC) << " seconds. " << it->first << " " << it->second << " * " << iSolution << std::endl; } std::cout << "The number of all valid Sudoku grids is the sum (3,546,146,300,288) multiply 9! * 72 * 72." << std::endl; std::cout << "The result is 6,670,903,752,021,072,936,960, or 6.671 * (10 ^ 21)." << std::endl; } // int main(int argc, char **argv) { unsigned int iClassToSkip; unsigned int iJobs; try { po::variables_map vm; po::options_description desc("Allowed options"); po::positional_options_description pd; desc.add_options()("enum,e", po::value<unsigned int>(&iClassToSkip)->implicit_value(0), "enumerate top row of blocks equivalence classes, count solutions for all but the first N classes."); desc.add_options()("help,h", "this help message."); desc.add_options()("jobs,j", po::value<unsigned int>(&iJobs)->default_value(0), "jobs at once, 0 for full hardware capacity, only effective with -e option."); desc.add_options()("problem,p", po::value<std::string>(), "problem string like [0123456789]+."); pd.add("problem", -1); po::store(po::command_line_parser(argc, argv).options(desc).allow_unregistered().positional(pd).run(), vm); po::notify(vm); if (vm.count("problem")) { Solve(vm["problem"].as<std::string> ().c_str()); return 0; } if (vm.count("help") || !vm.count("enum")) { std::cout << "Usage: " << argv[0] << " [-p] problem-string" << std::endl; std::cout << " " << argv[0] << " -e [N-to-skip] [-j jobs]" << std::endl; std::cout << " " << argv[0] << " -h" << std::endl; std::cout << desc; return 0; } if (vm.count("enum")) { Enumerate(iClassToSkip, iJobs); return 0; } } catch (std::exception& e) { std::cout << e.what() << std::endl; std::cout << "Use /"" << argv[0] << " --help/"" << " for detailed options." << std::endl; return 1; } // should never get here assert(0); std::cout << "Use /"" << argv[0] << " --help/"" << " for detailed options." << std::endl; return 2; }

test.txt

sudoku.exe 123456789456789123789123456214365897365897214897214365531642978642978531978531642 sudoku.exe 123456789456789123789123456214365897365897214897214365531642978642978531978531643 sudoku.exe 123456789456789123789123456214365897365897214897214365531642978642978531978531652 sudoku.exe 123456789456789123789123456214365897 sudoku.exe 123456789456789123789123456000000000214365897 sudoku.exe 123456789456789123789123456000000000000000000214365897 sudoku.exe 123456789456789123789123456000000000000000000000000000214365897 sudoku.exe 123456789456789123789123456000000000000000000000000000000000000214365897 sudoku.exe 123456789456789123789123456000000000000000000000000000000000000000000000214365897 sudoku.exe 000000000000000000000000000123456789456789123789123456214365897 sudoku.exe 000000000000000000000000000123456789456789123789123456000000000214365897 sudoku.exe 000000000000000000000000000123456789456789123789123456000000000000000000214365897 sudoku.exe 214365897000000000000000000000000000000000000000000000123456789456789123789123456 sudoku.exe 000000000214365897000000000000000000000000000000000000123456789456789123789123456 sudoku.exe 000000000000000000214365897000000000000000000000000000123456789456789123789123456 sudoku.exe 000000000000000000000000000214365897000000000000000000123456789456789123789123456 sudoku.exe 000000000000000000000000000000000000214365897000000000123456789456789123789123456 sudoku.exe 000000000000000000000000000000000000000000000214365897123456789456789123789123456 sudoku.exe 0053000008000000200700105004000053000100700060032000800605000090040000300000097 sudoku.exe 1234567894567891237891234562143658973658972148972143655316429786429785319785316420000 sudoku.exe 12345678945678912378912345621436589736589721489721436553164297864297853197853164299999 sudoku.exe 1234567894567891237891234562143658973658972148972143655316429786429785319785316430000 sudoku.exe 12345678945678912378912345621436589736589721489721436553164297864297853197853164399999 sudoku.exe 1234567894567891237891234562143658973658972148972143655316429786429785319785316520000 sudoku.exe 12345678945678912378912345621436589736589721489721436553164297864297853197853165299999 sudoku.exe 123456789 sudoku.exe 147200000258100000369400000471300000582600000693500000714800000825900000936700000 sudoku.exe 147020000258010000369040000471030000582060000693050000714080000825090000936070000

result.txt

Count solutions for each equivalence class. Class 1:..........309.567 seconds. 123456789456789123789123456 4 * 108374976 Class 2:..........302.718 seconds. 123456789456789123789123465 108 * 102543168 Class 3:..........303.655 seconds. 123456789456789123789123564 72 * 100231616 Class 4:..........299.754 seconds. 123456789456789123789132465 216 * 102047904 Class 5:..........299.287 seconds. 123456789456789123789132546 432 * 98875264 Class 6:..........299.443 seconds. 123456789456789123789132564 2592 * 98733568 Class 7:..........297.102 seconds. 123456789456789123789231564 576 * 97685328 Class 8:..........297.711 seconds. 123456789456789123789231645 516 * 98950072 Class 9:..........298.756 seconds. 123456789456789132789123546 216 * 99083712 Class 10:..........297.821 seconds. 123456789456789132789213456 216 * 99525184 Class 11:..........295.932 seconds. 123456789456789132789213546 1296 * 98369440 Class 12:..........294.107 seconds. 123456789456789132789213645 1512 * 97287008 Class 13:..........294.061 seconds. 123456789456789132789213654 648 * 98128064 Class 14:..........294.403 seconds. 123456789456789132789231546 756 * 98153104 Class 15:..........293.733 seconds. 123456789456789132789231564 2484 * 97961464 Class 16:..........294.576 seconds. 123456789456789231789123645 24 * 97282720 Class 17:..........294.715 seconds. 123456789456789231789312456 12 * 99258880 Class 18:..........292.236 seconds. 123456789456798132789213546 2052 * 97477096 Class 19:..........292.952 seconds. 123456789456798132789213645 684 * 97549160 Class 20:..........287.353 seconds. 123456789456798132789231546 756 * 96702240 Class 21:..........286.245 seconds. 123456789456897312789312564 20 * 94888576 Class 22:..........297.04 seconds. 123457689456189237789263145 3240 * 97116296 Class 23:..........298.928 seconds. 123457689456189237789263154 1188 * 98371664 Class 24:..........300.628 seconds. 123457689456189237789263514 2592 * 97539392 Class 25:..........292.391 seconds. 123457689456189237789362145 2808 * 96482296 Class 26:..........293.92 seconds. 123457689456189237789362154 756 * 97346960 Class 27:..........298.117 seconds. 123457689456189273789263145 1512 * 97910032 Class 28:..........299.162 seconds. 123457689456189273789263154 324 * 98493856 Class 29:..........300.659 seconds. 123457689456189273789263514 864 * 98119872 Class 30:..........300.753 seconds. 123457689456189273789623154 864 * 98733184 Class 31:..........296.104 seconds. 123457689456189273789632154 648 * 97455648 Class 32:..........293.109 seconds. 123457689456189327789362145 1944 * 97416016 Class 33:..........298.429 seconds. 123457689456189723789623145 432 * 98784768 Class 34:..........307.149 seconds. 123457689456189723789623154 144 * 101131392 Class 35:..........298.647 seconds. 123457689456189723789623514 432 * 97992064 Class 36:..........295.23 seconds. 123457689456189723789632154 864 * 97756224 Class 37:..........292.594 seconds. 123457689456189732789623514 324 * 96380896 Class 38:..........291.799 seconds. 123457689456198723789632514 324 * 97714592 Class 39:..........286.946 seconds. 123457689456198732789632514 252 * 96100688 Class 40:..........290.208 seconds. 123457689456289137789361254 288 * 96807424 Class 41:..........295.121 seconds. 123457689456289137789631524 288 * 96631520 Class 42:..........295.199 seconds. 123457689456289173789613245 360 * 97372400 Class 43:..........290.676 seconds. 123457689456289731789613542 540 * 95596592 Class 44:..........292.594 seconds. 123457689456398721789612345 108 * 98048704

//

1. Solve a Sudoku problem:

sudoku.exe 0053000008000000200700105004000053000100700060032000800605000090040000300000097

---+---+---
..5 3.. ...
8.. ... .2.
.7. .1. 5..
   +   +
4.. ..5 3..
.1. .7. ..6
..3 2.. .8.
   +   +
.6. 5.. ..9
..4 ... .3.
... ..9 7..
0.059 seconds has elapsed for the first solution.
---+---+---
145 327 698
839 654 127
672 918 543
   +   +
496 185 372
218 473 956
753 296 481
   +   +
367 542 819
984 761 235
521 839 764
0.105 seconds has elapsed. Found total 1 solution.

 

//

2. Calculate the possibilities for all valid Sudoku grids:

sudoku.exe -e -j 2

0.155 seconds has elapsed.
Found total 36288 possibilities for the top row of blocks, with the fixed top le
ft block (B1) and lexicographical reduced B2 and B3.

12.957 seconds has elapsed.
Found total 36288 possibilities as 2051 equivalence classes, after refined colum
n permutation and relabeling.

13.144 seconds has elapsed.
Found total 36288 possibilities as 44 equivalence classes, after refined row per
mutation and relabeling.
The list of a representative and the size of each equivalence class:

Class 1: 123456789456789123789123456 4
Class 2: 123456789456789123789123465 108
Class 3: 123456789456789123789123564 72
Class 4: 123456789456789123789132465 216
Class 5: 123456789456789123789132546 432
Class 6: 123456789456789123789132564 2592
Class 7: 123456789456789123789231564 576
Class 8: 123456789456789123789231645 516
Class 9: 123456789456789132789123546 216
Class 10: 123456789456789132789213456 216
Class 11: 123456789456789132789213546 1296
Class 12: 123456789456789132789213645 1512
Class 13: 123456789456789132789213654 648
Class 14: 123456789456789132789231546 756
Class 15: 123456789456789132789231564 2484
Class 16: 123456789456789231789123645 24
Class 17: 123456789456789231789312456 12
Class 18: 123456789456798132789213546 2052
Class 19: 123456789456798132789213645 684
Class 20: 123456789456798132789231546 756
Class 21: 123456789456897312789312564 20
Class 22: 123457689456189237789263145 3240
Class 23: 123457689456189237789263154 1188
Class 24: 123457689456189237789263514 2592
Class 25: 123457689456189237789362145 2808
Class 26: 123457689456189237789362154 756
Class 27: 123457689456189273789263145 1512
Class 28: 123457689456189273789263154 324
Class 29: 123457689456189273789263514 864
Class 30: 123457689456189273789623154 864
Class 31: 123457689456189273789632154 648
Class 32: 123457689456189327789362145 1944
Class 33: 123457689456189723789623145 432
Class 34: 123457689456189723789623154 144
Class 35: 123457689456189723789623514 432
Class 36: 123457689456189723789632154 864
Class 37: 123457689456189732789623514 324
Class 38: 123457689456198723789632514 324
Class 39: 123457689456198732789632514 252
Class 40: 123457689456289137789361254 288
Class 41: 123457689456289137789631524 288
Class 42: 123457689456289173789613245 360
Class 43: 123457689456289731789613542 540
Class 44: 123457689456398721789612345 108

Count solutions for each equivalence class.

Class 1:..........309.567 seconds. 123456789456789123789123456 4 * 108374976
Class 2:..........302.718 seconds. 123456789456789123789123465 108 * 102543168
Class 3:..........303.655 seconds. 123456789456789123789123564 72 * 100231616
Class 4:..........299.754 seconds. 123456789456789123789132465 216 * 102047904
Class 5:..........299.287 seconds. 123456789456789123789132546 432 * 98875264
Class 6:..........299.443 seconds. 123456789456789123789132564 2592 * 98733568
Class 7:..........297.102 seconds. 123456789456789123789231564 576 * 97685328
Class 8:..........297.711 seconds. 123456789456789123789231645 516 * 98950072
Class 9:..........298.756 seconds. 123456789456789132789123546 216 * 99083712
Class 10:..........297.821 seconds. 123456789456789132789213456 216 * 99525184
Class 11:..........295.932 seconds. 123456789456789132789213546 1296 * 98369440
Class 12:..........294.107 seconds. 123456789456789132789213645 1512 * 97287008
Class 13:..........294.061 seconds. 123456789456789132789213654 648 * 98128064
Class 14:..........294.403 seconds. 123456789456789132789231546 756 * 98153104
Class 15:..........293.733 seconds. 123456789456789132789231564 2484 * 97961464
Class 16:..........294.576 seconds. 123456789456789231789123645 24 * 97282720
Class 17:..........294.715 seconds. 123456789456789231789312456 12 * 99258880
Class 18:..........292.236 seconds. 123456789456798132789213546 2052 * 97477096
Class 19:..........292.952 seconds. 123456789456798132789213645 684 * 97549160
Class 20:..........287.353 seconds. 123456789456798132789231546 756 * 96702240
Class 21:..........286.245 seconds. 123456789456897312789312564 20 * 94888576
Class 22:..........297.04 seconds. 123457689456189237789263145 3240 * 97116296
Class 23:..........298.928 seconds. 123457689456189237789263154 1188 * 98371664
Class 24:..........300.628 seconds. 123457689456189237789263514 2592 * 97539392
Class 25:..........292.391 seconds. 123457689456189237789362145 2808 * 96482296
Class 26:..........293.92 seconds. 123457689456189237789362154 756 * 97346960
Class 27:..........298.117 seconds. 123457689456189273789263145 1512 * 97910032
Class 28:..........299.162 seconds. 123457689456189273789263154 324 * 98493856
Class 29:..........300.659 seconds. 123457689456189273789263514 864 * 98119872
Class 30:..........300.753 seconds. 123457689456189273789623154 864 * 98733184
Class 31:..........296.104 seconds. 123457689456189273789632154 648 * 97455648
Class 32:..........293.109 seconds. 123457689456189327789362145 1944 * 97416016
Class 33:..........298.429 seconds. 123457689456189723789623145 432 * 98784768
Class 34:..........307.149 seconds. 123457689456189723789623154 144 * 101131392
Class 35:..........298.647 seconds. 123457689456189723789623514 432 * 97992064
Class 36:..........295.23 seconds. 123457689456189723789632154 864 * 97756224
Class 37:..........292.594 seconds. 123457689456189732789623514 324 * 96380896
Class 38:..........291.799 seconds. 123457689456198723789632514 324 * 97714592
Class 39:..........286.946 seconds. 123457689456198732789632514 252 * 96100688
Class 40:..........290.208 seconds. 123457689456289137789361254 288 * 96807424
Class 41:..........295.121 seconds. 123457689456289137789631524 288 * 96631520
Class 42:..........295.199 seconds. 123457689456289173789613245 360 * 97372400
Class 43:..........290.676 seconds. 123457689456289731789613542 540 * 95596592
Class 44:..........292.594 seconds. 123457689456398721789612345 108 * 98048704

The number of all valid Sudoku grids is the sum (3,546,146,300,288) multiply 9!
* 72 * 72.
The result is 6,670,903,752,021,072,936,960, or 6.671 * (10 ^ 21).