数独的一个解法

     公司茶水间打扫卫生的人很喜欢研究数独问题，经常一个人拿着报纸解上面的数独问题，一次遇到了一个难度为四级的问题拿来问我，我研究了一会没做出来，真是没面子，因此想到写一个小程序来解决。程序只是简单的尝试每一个可能的数字。根据输入数据的情况，来排除一些无效的数字情况。

#include  < stdio.h >

#define  N   9
#define  VALID   (1)
#define  INVALID (-1)
struct  item  
{
     int  x,y,value;
     struct  item  *  next;
};

class  Item
{
public :
    Item()
    {
         int  i ;
         for (i  =   0  ; i  <  N ; i  ++  ) {
            data[i]  =  VALID;
            m_nValid  =  N ;
        }
        
        m_origit  =   false ;
        m_nIndicator  =   0 ;
        m_nCurValue  =   0 ;
    }
     void  SetNInvalid( int  n)  /*  index value  */
    {
        data[n]  =  INVALID;
        m_nValid  -- ;
    }
     int  GetValid()
    {
         return  m_nValid;
    }
     void  SetOrigi( int  nvalue)  /*  value in the map, it should be the index +1  */
    {
        m_origit  =   true  ;
        m_nCurValue  =  nvalue;
         for ( int  i  =   0  ; i  <  N ; i  ++ )
        {
             if (i  +   1   !=  nvalue)
            {
                SetNInvalid(i);
            }
        }
    }
     int  GetCurrentValue()
    {
         return  m_nCurValue;
    }
     void  SetCurrentValue( int  n)
    {
        m_nCurValue  =  n;
    }
     bool  IsOrigi()   /*  1 origit ; 0 not origit  */
    {
         return  m_origit ;
    }
     void  ResetIndicator()
    {
        m_nIndicator  =   0 ;
        m_nCurValue  =   0  ;
    }

     int  GetNextPossibleValue()
    {
         while (m_nIndicator  <  N  &&  data[m_nIndicator ]  ==  INVALID) {
            m_nIndicator ++ ;
        }
        m_nIndicator  ++  ;
         if (m_nIndicator  >  N) {
             return   - 1 ;
        }
         return  (m_nIndicator );
    }
    
     void  PrintPossibleValue()
    {
         int  i ;
         for (i  =   0  ; i  <  N ; i  ++ )
        {
             if (data[i]  ==  VALID)
            {
                printf( "  %d  " , i  +   1 );
            }
        }
    }

     int   data[N] ;
     bool  m_origit;
     int  m_nValid;
     int  m_nIndicator ;
     int  m_nCurValue;
};

class  CGroupMap
{
public :
    CGroupMap()
    {
    }
    
     void  InitMap( struct  item  *  first)
    {
         while (first)
        {
            SetItem(first);
            first  =  first -> next;
        }
    }
     void  SetItem( struct  item  *  it)
    {
         int  i ;
        m_map[it -> x][it -> y].SetOrigi(it -> value);
        
         for (i  =   0  ; i  <  N ; i  ++  )
        {
             if ( i  !=  it -> y) {
                m_map[it -> x][i].SetNInvalid(it -> value   -   1 );
            }
        }

         for (i  =   0  ; i  <  N ; i  ++ )
        {
             if ( i  !=  it -> x)
            {
                m_map[i][it -> y].SetNInvalid(it -> value  -   1 );
            }
        }
    }
     bool  Checkvalue( int  x,  int  y ,  int  value)
    {
         int  i , j;
         if (value  <   0   ||  value  >  N)  return   false ;
         for ( i  =   0  ; i  <  N ; i  ++ )
        {
             if (i  !=  y) {
                 if (m_map[x][i].GetCurrentValue()  ==  value)
                {
                     return   false ;
                }
            }
        }

         for ( i  =   0  ; i  <  N ; i  ++ )
        {
             if ( i  !=  x)
            {
                 if (m_map[i][y].GetCurrentValue()  ==  value)
                {
                     return   false ;
                }
            }
        }

         int  fx , fy ,mx,my;
        
        fx  =  x  / 3  ;
        fx  =  fx  *   3 ;
        mx  =  fx  +   3 ;

        fy  =  y  /   3 ;
        fy  =  fy  *   3 ;
        my  =  fy  +   3 ;

         for (i  =  fx ; i  <  mx ; i  ++ )
             for ( j  =  fy ; j  <  my ; j  ++ )
            {
                 if (i  ==  x  &&  j  ==  y)  continue ;
                 if (m_map[i][j].GetCurrentValue()  ==  value)
                     return   false ;
            }
         return   true ;
    }

     void  StartCal()
    {
         int  x  =   0  , y  =   0  ;
         int  value ;

         while (x  <  N)
        {
             while ( y  <  N)
            {
                 if (m_map[x][y].IsOrigi()  ==   true ) {
                    y  ++  ;
                     continue ;
                }

                 do {
                    value  =  m_map[x][y].GetNextPossibleValue() ;                    
                } while (value  >   0   &&   Checkvalue(x,y,value)  ==   false );
                
                
                 if (value  >    0  )
                {
                        m_map[x][y].SetCurrentValue(value);
                        y  ++  ;
                }
                 else
                {
                    m_map[x][y].SetCurrentValue( 0 );
                    m_map[x][y].ResetIndicator();

                     do
                    {
                         if (y  ==   0  ) 
                        {
                            x  --  ;
                            y  =  N  -   1 ;
                        }
                         else  
                        {
                            y  -- ;
                        }
                    } while (m_map[x][y].IsOrigi());
                }
                
            }
            x  ++ ;
            y  =   0  ;
             // Show();
        }
    }

     void  Show()
    {
         int  i , j ;
        printf( " " );
         for (i  =   0  ; i  <  N ; i  ++ )
             for (j  =   0  ; j  <  N ; j  ++ )
            {
                 if (i  &&  j  %  N  ==   0 ) printf( " " );
                printf( "  %d  " , m_map[i][j].GetCurrentValue());
            }
      printf( " " );
    }

     void  DumpPossible()
    {
         int  i ,j ;
         for (i  =   0  ; i  <  N ; i  ++ )
             for (j  =   0  ; j  <  N ; j  ++ )
            {
                printf( " (%d,%d) :  " ,i ,j );
                m_map[i][j].PrintPossibleValue();
                printf( " " );
            }
    }
    Item   m_map[N][N] ;
};


struct  item  itArra[]  =
    {
        { 0 , 0 , 5 , NULL},
        { 0 , 3 , 1 , NULL},
        { 0 , 4 , 8 , NULL},
        { 0 , 5 , 2 , NULL},
        { 0 , 7 , 4 , NULL},
        { 1 , 3 , 6 , NULL},
        { 1 , 5 , 7 , NULL},
        { 1 , 7 , 2 , NULL},
        { 2 , 5 , 5 , NULL},
        { 2 , 6 , 8 , NULL},
        { 3 , 0 , 8 , NULL},
        { 3 , 4 , 7 , NULL},
        { 3 , 7 , 9 , NULL},
        { 4 , 0 , 7 , NULL},
        { 4 , 1 , 2 , NULL},
        { 4 , 7 , 1 , NULL},
        { 4 , 8 , 5 , NULL},
        { 5 , 1 , 4 , NULL},
        { 5 , 4 , 1 , NULL},
        { 5 , 8 , 7 , NULL},
        { 6 , 2 , 7 , NULL},
        { 6 , 3 , 8 , NULL},
        { 6 , 6 , 9 , NULL},
        { 7 , 1 , 9 , NULL},
        { 7 , 3 , 3 , NULL},
        { 7 , 5 , 1 , NULL},
        { 8 , 1 , 8 , NULL},
        { 8 , 3 , 7 , NULL},
        { 8 , 4 , 5 , NULL},
        { 8 , 5 , 9 , NULL},
        { 8 , 8 , 4 , NULL},
        { 0 , 0 , 0 , ( struct  item  * )  1 }
    };

int  main()
{
    CGroupMap  gm;
     struct  item  *  first  =  NULL;
     struct  item  *  tmp  =  itArra ;
     struct  item  *  cur  =  NULL ;
     struct  item  *  it ;
     while (tmp -> next  ==  NULL)
    {
        it  =  ( struct  item  *  )  new  item;
         * it  =   *  tmp;

         if (first  ==  NULL) {
            first  =  it ;
            cur  =  it;
        }  else  {
            cur -> next  =  it;
            cur  =  it;
        }
        tmp  ++ ;
    }

    gm.InitMap(first);
     // gm.DumpPossible();
    gm.StartCal();
    gm.Show();
     return   0 ;
}