数独的C++解法

grid.h

#ifndef _GRID_H_
#define _GRID_H_

#include <set>
#include <cstddef>

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

    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 ( 1 == size() ) { return *(value_s.begin()); }
        return -1;
    }

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

    int value( int index ) {
        if ( index >= size() ) { return -1; }
        std::set<int>::iterator it = value_s.begin();
        for ( int i = 0; 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[9][9];
    bool operator < (const Result &result) const {
        for ( int i = 0; i < 9; i++ ) {
            for ( int j = 0; j < 9; j++ ) {
                if (value[i][j] < result.value[i][j]) { return true; }
            }
        }
        return false;
    }
};

class Sudoku {
public:
    Sudoku() {
        for ( int i = 0; i < 9; i++ ) {
            for ( int j =0; j < 9; 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 = 0; 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[9][9];
    bool fixed[9][9];
    
    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 = 0; j < 9; j++) {
            if ( j != jj ) { if ( !grid[ii][j].remove(value) ) { return false; } }
        }
        for (int i = 0; i < 9; i++) {
            if ( i != ii ) { if ( !grid[i][jj].remove(value) ) { return false; } }
        }
        for (int i = (ii/3) * 3; i < (ii/3) * 3 + 3; i++ ) {
            for ( int j = (jj/3) * 3; j < (jj/3) * 3 + 3; 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 = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                if ( !fixed[i][j] && 1 == 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 = 9;
        for (int i = 0; i < 9; i++ ) {
            for ( int j = 0; j < 9; 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 = 0; i < 9; i++ ) {
            for ( int j = 0; j < 9; j++ ) {
                if ( !fixed[i][j] ) { return false; }
            }
        }
        return true;
    }
    
    void fill_result( std::set<Result>& result_s ) {
        Result result;
        for ( int i = 0; i < 9; i++ ) {
            for ( int j = 0; j < 9; 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(0, 0, 8));
    pos_val_s.insert(PosVal(1, 2, 3));
    pos_val_s.insert(PosVal(1, 3, 6));
    pos_val_s.insert(PosVal(2, 1, 7));
    pos_val_s.insert(PosVal(2, 4, 9));
    pos_val_s.insert(PosVal(2, 6, 2));
    pos_val_s.insert(PosVal(3, 1, 5));
    pos_val_s.insert(PosVal(3, 5, 7));
    pos_val_s.insert(PosVal(4, 4, 4));
    pos_val_s.insert(PosVal(4, 5, 5));
    pos_val_s.insert(PosVal(4, 6, 7));
    pos_val_s.insert(PosVal(5, 3, 1));
    pos_val_s.insert(PosVal(5, 7, 3));
    pos_val_s.insert(PosVal(6, 2, 1));
    pos_val_s.insert(PosVal(6, 7, 6));
    pos_val_s.insert(PosVal(6, 8, 8));
    pos_val_s.insert(PosVal(7, 2, 8));
    pos_val_s.insert(PosVal(7, 3, 5));
    pos_val_s.insert(PosVal(7, 7, 1));
    pos_val_s.insert(PosVal(8, 1, 9));
    pos_val_s.insert(PosVal(8, 6, 4));
    
    Sudoku s;
    if ( !s.Init( pos_val_s ) ) {
        return -1;
    }
    
    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 = 0; i < 9; i++ ) {
            for ( int j = 0; j < 9; j++ ) {
                std::cout << it->value[i][j] << " ";
            }
            std::cout << std::endl;
        }
    }
}