数独的C++解法

grid.h

 #ifndef _GRID_H_
 #define _GRID_H_

 #include <set>
 #include <cstddef>

 class Grid {
 public:
     Grid() { for ( int i = ; i < ; i++ ) { value_s.insert(i + ); } }

     bool set( int value ) {
         if ( !contain(value) ) { return false; }
         value_s.clear();
         value_s.insert(value);
         return true;
     }

     size_t size() { return value_s.size(); }

     int value() {
         if (  == size() ) { return *(value_s.begin()); }
         return -;
     }

     bool remove(int value) {
         value_s.erase(value);
         if (  == size() ) { return false; }
         return true;
     }

     int value( int index ) {
         if ( index >= size() ) { return -; }
         std::set<int>::iterator it = value_s.begin();
         for ( int i = ; i < index; i++ ) { it ++; }
         return *it;
     }
 private:
     std::set<int> value_s;

     bool contain( int value ) { return ( value_s.end() != value_s.find(value) ); }
 };

 #endif

sudoku.h

 #ifndef _SUDOKU_H_
 #define _SUDOKU_H_

 #include "grid.h"

 struct PosVal {
     int i;
     int j;
     int val;
     PosVal( int _i, int _j, int _val ) : i(_i), j(_j), val(_val) {}
     bool operator < (const PosVal &pos_val) const {
         return ( i == pos_val.i ) ? (j < pos_val.j ) : ( i < pos_val.i );
     }
 };

 struct Result {
     int value[][];
     bool operator < (const Result &result) const {
         for ( int i = ; i < ; i++ ) {
             for ( int j = ; j < ; j++ ) {
                 if (value[i][j] < result.value[i][j]) { return true; }
             }
         }
         return false;
     }
 };

 class Sudoku {
 public:
     Sudoku() {
         for ( int i = ; i < ; i++ ) {
             for ( int j =; j < ; j++ ) {
                 fixed[i][j] = false;
             }
         }
     }

     bool Init( const std::set<PosVal>& pos_val_s) {
         for ( std::set<PosVal>::iterator it = pos_val_s.begin(); it != pos_val_s.end(); it++ ) {
             if ( ! set( it->i, it->j, it->val ) ) { return false; }
         }
         return true;
     }

     void calc( std::set<Result>& result_s ) {
         if ( !trim() ) { return; }
         if ( all_grid_fixed() ) { fill_result( result_s ); return; }
         int i, j;
         find_unfixed_min_size_grid(i, j);
         for ( int loop = ; loop < size(i, j); loop ++ ) {
             Sudoku s( *this );
             if ( !s.set(i, j, value(i, j, loop)) ) { return; }
             s.calc( result_s );
         }
     }
 private:
     Grid grid[][];
     bool fixed[][];

     bool set(int i, int j, int value) {
         if ( !grid[i][j].set(value) ) { return false; }
         if ( !trim(i, j, value) ) { return false; }
         fixed[i][j] = true;
         return true;
     }

     size_t size(int i, int j) { return grid[i][j].size(); }

     int value(int i, int j ) { return grid[i][j].value(); }

     int value(int i, int j, int index) { return grid[i][j].value(index); }

     bool trim(int ii, int jj, int value) {
         for (int j = ; j < ; j++) {
             if ( j != jj ) { if ( !grid[ii][j].remove(value) ) { return false; } }
         }
         for (int i = ; i < ; i++) {
             if ( i != ii ) { if ( !grid[i][jj].remove(value) ) { return false; } }
         }
         for (int i = (ii/) * ; i < (ii/) *  + ; i++ ) {
             for ( int j = (jj/) * ; j < (jj/) *  + ; j++ ) {
                 if ( ( i != ii ) || ( j != jj ) ) { if ( !grid[i][j].remove(value) ) { return false; } }
             }
         }
         return true;
     }

     bool trim() {
         bool has_new_fixed_grid = false;
         for (int i = ; i < ; i++) {
             for (int j = ; j < ; j++) {
                 if ( !fixed[i][j] &&  == size(i, j) ) {
                     has_new_fixed_grid = true;
                     if ( !set(i, j, value(i, j)) ) { return false; }
                 }
             }
         }
         if ( has_new_fixed_grid ) { return trim(); }
         return true;
     }

     void find_unfixed_min_size_grid(int &ii, int &jj) {
         size_t min_size = ;
         for (int i = ; i < ; i++ ) {
             for ( int j = ; j < ; j++) {
                 if ( !fixed[i][j] ) {
                     if ( size(i, j) < min_size ) { ii = i; jj = j; min_size = size(i, j); }
                 }
             }
         }
     }

     bool all_grid_fixed() {
         for ( int i = ; i < ; i++ ) {
             for ( int j = ; j < ; j++ ) {
                 if ( !fixed[i][j] ) { return false; }
             }
         }
         return true;
     }

     void fill_result( std::set<Result>& result_s ) {
         Result result;
         for ( int i = ; i < ; i++ ) {
             for ( int j = ; j < ; j++ ) {
                 result.value[i][j] = value(i, j);
             }
         }
         result_s.insert( result );
     }
 };

 #endif

main.cpp

 #include "sudoku.h"
 #include <iostream>

 int main() {
     std::set<PosVal> pos_val_s;
     pos_val_s.insert(PosVal(, , ));
     pos_val_s.insert(PosVal(, , ));
     pos_val_s.insert(PosVal(, , ));
     pos_val_s.insert(PosVal(, , ));
     pos_val_s.insert(PosVal(, , ));
     pos_val_s.insert(PosVal(, , ));
     pos_val_s.insert(PosVal(, , ));
     pos_val_s.insert(PosVal(, , ));
     pos_val_s.insert(PosVal(, , ));
     pos_val_s.insert(PosVal(, , ));
     pos_val_s.insert(PosVal(, , ));
     pos_val_s.insert(PosVal(, , ));
     pos_val_s.insert(PosVal(, , ));
     pos_val_s.insert(PosVal(, , ));
     pos_val_s.insert(PosVal(, , ));
     pos_val_s.insert(PosVal(, , ));
     pos_val_s.insert(PosVal(, , ));
     pos_val_s.insert(PosVal(, , ));
     pos_val_s.insert(PosVal(, , ));
     pos_val_s.insert(PosVal(, , ));
     pos_val_s.insert(PosVal(, , ));

     Sudoku s;
     if ( !s.Init( pos_val_s ) ) {
         return -;
     }

     std::set<Result> result_s;
     s.calc( result_s );
     for ( std::set<Result>::iterator it = result_s.begin(); it != result_s.end(); it++ ) {
         for ( int i = ; i < ; i++ ) {
             for ( int j = ; j < ; j++ ) {
                 std::cout << it->value[i][j] << " ";
             }
             std::cout << std::endl;
         }
     }
 }