C++ Sudoku类代码示例

int main(){
	Sudoku ss;
	ss.readIn();
	ss.transform();
	return 0;

}

int main(){
    Sudoku *solvedPuzzle;
    //    int i = 0;
    //    int n = 0; //length
    //
    //
    std::string input;
    string t;
    for (int i = 0; i < 9; i++) {
        cin >> input;
        if (input.size()>10) {
            t = input;
            break;
        }
        t = t + input;
    }
    
    
    Sudoku puzzle = Sudoku(t);
    std::cout << "\n";
    std::cout << puzzle << endl;
    //    std::cout << "\n" << endl;
    puzzle.finalize();
    //    cout << "hi" << endl;            //test
    solvedPuzzle = solve (&puzzle);
    if (solvedPuzzle == NULL) {
        std:: cerr << "ERROR: nonSolvable puzzle" << endl;
    }
    else
        std::cout << *solvedPuzzle;
    return 0;
}

bool Sudoku::solve()
{
  if(fin()){
    return true; 
  }
  while(1){
    Move m = findMove();
    if(m.val == 0){
      //no more moves
      return false;
    }
    Sudoku scopy = *this;
    bool result = scopy.applyMove(m);
    if(!result){
      cand[m.ii][m.jj][m.val] = false;
      continue;
    }
    result = scopy.solve();
    if(result){
      *this = scopy;
      return true;
    }else{
      cand[m.ii][m.jj][m.val] = false;
    }
  }
  return false;
}

void RecursiveSolver::solve(Sudoku& sudoku) {
	this->_field = sudoku.getField();
	options = findMissing();
	
	for(map<int,vector<int>>::iterator it = options.begin(); it != options.end(); ++it) {
		cout << it->first << " " << ": ";
		for (vector<int>::iterator it2 = it->second.begin(); it2 != it->second.end(); ++it2) {
			cout << *it2 << ", ";
		}
		cout << endl;
	}
	map<int,vector<int>>::iterator it = options.begin();
	count = 0;
	
	int status = -1;
	do {
		status = guess(it->first);
		switch(status) {
		case RETURN_NEXT:
			it = std::next(it);
			break;
		case RETURN_PREV:
			it = std::prev(it);
			break;
		}
	} while(status != RETURN_EXIT);
	
	
	sudoku.setField(_field);
}

int main(int argc, const char * argv[]) {
    
    Sudoku ss;
    ss.giveQuestion();
    
    return 0;
}

// smazani policka probiha tak, ze se zkopiruje cele sudoku az na pole, ktere mazeme. je to nutne kvuli obnove zakazanyvh poli v radcich/sloupcich/ctvercich
int Sudoku::smazat ( int x, int y )
{
  int u,v, smazano = false;
  if(!s.pole[y*9+x].zapsane || s.pole[y*9+x].pevne) // pokud na pozici nic neni nebo je tam pevne cislo, nic se nedeje
    return false;
  Sudoku temp (-1); // prazdne sudoku pro doplnovani
  // projdeme vse
  for (int i = 0;i < 81; i++)
  {
    // vynechavame pri kopirovani mazane policko
    if(i/9 == y && i%9 == x)
    {
      smazano = true;
      continue;
    }
    // nezapisujeme prazdna policka, doslo by k zaseknuti
    if (!s.pole[i].zapsane)
      continue;
    // doplnime zpet policko
    temp.doplnM (i%9, i/9, s.pole[i].zapsane);
    temp.s.pole[i].pevne = s.pole[i].pevne;
  }
  s = temp.s; // preneseni stavu do tohoto sudoku z docasneho
  return smazano;
}

int main()
{ 
	time_t start = time(NULL);
	
	std::string line;
	std::ifstream in;
	in.open("sudoku.txt");
	Sudoku x;
	int result = 0;
	for(int i = 0; i < 50; ++i)
	{
		getline(in,line);

		in >> x;
		Point p = x.getFirstEmpty();
		solve(x,p.i,p.j);
		
		std::cout << x << std::endl;
		result += getFirstThree(x);
	}

	std::cout << result << std::endl;
	printf("It took %d seconds\n", (time(NULL)-start));
	
}

/**
 * Main method that gets initialized upon start of the program and creates an instance of the class Sudoku. A function
 * belonging to the Sudoku class is called that will generate a completely solved sudoku board and then the pointer to
 * the class is deleted to free up the allocated memory.
 */
int main() {
    Sudoku * mySudoku = new Sudoku();
    mySudoku->solve();
    delete mySudoku;

    return 0;
}

constexpr Cell next(const Sudoku& s)
{
  for(size_t i=0; i<s.dimension(); ++i)
    for(size_t j=0; j<s.dimension(); ++j)
      if (s(i,j) == 0) return {i,j};
  return {std::numeric_limits<Cell::first_type>::max(),std::numeric_limits<Cell::second_type>::max()};
}

int main()
{
	Sudoku ss;
	ss.ReadIn();
	ss.Solve();
	return 0;
}

constexpr bool finished(const Sudoku& s)
{
  for(size_t i=0; i<s.dimension(); ++i)
    for(size_t j=0; j<s.dimension(); ++j)
      if (s(i,j) == 0) return false;
  return true;
}

int main(){
	Sudoku ss;
	ss.readIn();
	ss.solve();

	return 0;
}

vector<PuzzleState*> Sudoku::getSuccessors() {
  assert(!isSolution()); // some move remains!

  vector<PuzzleState*> result;

  // find a blank square to fill in
  int row = 0;
  int col = 0;
  for (int i=0; i<9; i++) {
    for (int j=0; j<9; j++) {
      if (grid[i][j]==0) {
	row = i;
	col = j;
	// terminate the loop
	// no labelled breaks :(
	i = 9;
	j = 9;
      }
    }
  }

  for (int digit=1; digit<=9; digit++) {
    if (rowTally[row][digit]) continue; // digit already used in row
    if (colTally[col][digit]) continue; // digit already used in column
    if (zoneTally[row/3][col/3][digit]) continue; // digit already used in zone
    // This is a legal digit!  Add it to possible moves.
    Sudoku *temp = new Sudoku(*this);
    temp->applyMove(row,col,digit);
    result.push_back(temp);
  }

  return result;
}

int main()
{
	Sudoku ss;
	int num;
	int i,j,k;
	int count = 0;
	while(cin >> num)
	{
		count++;
		if(count!=1 && ans_count != 0)
			cout << endl << endl;
		else if(count !=1)
			cout << endl;
		for(i=0; i<9; i++)
		{
			for(j=0; j<9; j++)
			{
				su[i][j] = 0;
				su3[i][j][0] = 0;
				ans[i][j] = 0;
				su2[i][j] = 0;
				for(k=1; k<10; k++)
				{
					su3[i][j][k] = 1;
				}
			}
		}
		have_zero = false;
		ans_count = 0;
		ss.readIn(num);
		ss.solve(num);
	}
}

void sudokuTest() {
  vector< vector<int> > _grid = 
  {{3, 0, 6, 5, 0, 8, 4, 0, 0},
    {5, 2, 0, 0, 0, 0, 0, 0, 0},
    {0, 8, 7, 0, 0, 0, 0, 3, 1},
    {0, 0, 3, 0, 1, 0, 0, 8, 0},
    {9, 0, 0, 8, 6, 3, 0, 0, 5},
    {0, 5, 0, 0, 9, 0, 6, 0, 0},
    {1, 3, 0, 0, 0, 0, 2, 5, 0},
    {0, 0, 0, 0, 0, 0, 0, 7, 4},
    {0, 0, 5, 2, 0, 6, 3, 0, 0}};

  Sudoku* puzzle = new Sudoku( _grid );
  if(!puzzle->IsLegalBoard()) {
    drunkout("Illegal board.", cERROR);
  }
  puzzle->print();

  if(puzzle->solve())
    puzzle->print();
  else
    drunkout("No solution.", cINFO);

  delete puzzle;

}