Dancing Links

Dancing Links用来解决如下精确匹配的问题:

选择若干行使得每一列恰好有一个1。Dancing Links通过对非零元素建立双向十字循环链表。上面的例子建立的链表如下所示：

计算的时候使用搜索的策略。每次选出1最少的一列，比如c，然后选择这一列中的某一行，比如r，(r,c)=1,然后r中所有1所在的列，那些其他行这些列有1的都删掉（这些行不会在r算入答案后也在答案里，否则就有某些列多于一个1出现）。然后这就变成一个规模更小的问题，继续搜索。无解时要回溯。

 class CDancingLinks
 {
 protected:
     struct DancingLinksNode
     {
         DancingLinksNode* left;
         DancingLinksNode* right;
         DancingLinksNode* down;
         DancingLinksNode* up;
         int col;
         int row;
     };

     typedef DancingLinksNode Node;

     int *m_columnEleNumbers;
     int m_colNumber;
     int m_rowNumber;
     Node* m_pool;
     Node** m_head;
     int m_curUsePoolIndex;

     void _Remove(Node* cur)
     {
         --m_columnEleNumbers[cur->col];
         for(Node* p=cur->down;p!=cur;p=p->down)
         {
             p->left->right=p->right;
             p->right->left=p->left;
         }
     }

     void _Resume(Node* cur)
     {
         ++m_columnEleNumbers[cur->col];
         for(Node* p=cur->up;p!=cur;p=p->up)
         {
             p->left->right=p;
             p->right->left=p;
         }
     }

     bool _SearchSolution(const int depth,std::vector<int> &solution)
     {
         Node* p=_GetNode();
         if(p->left==p) return true;

         int Min=m_rowNumber+;
         int MinColumnIndex=;
         for(Node* q=p->left;q!=p;q=q->left)
         {
             if(m_columnEleNumbers[q->col]<Min)
             {
                 Min=m_columnEleNumbers[q->col];
                 MinColumnIndex=q->col;
             }
         }

         for(Node* q=_GetNode(MinColumnIndex)->down;q!=_GetNode(MinColumnIndex);q=q->down)
         {
             _Remove(q);
             solution.push_back(q->row);
             for(Node* rr=q->right;rr!=q;rr=rr->right) _Remove(rr);
             if(_SearchSolution(depth+,solution)) return true;
             for(Node* rr=q->left;rr!=q;rr=rr->left) _Resume(rr);
             solution.pop_back();
             _Resume(q);
         }

         return false;
     }

     Node* _GetNode(int id) { return m_pool+id; }

     void _ReleaseMemory()
     {
          if(m_columnEleNumbers)
         {
             delete[] m_columnEleNumbers;
             m_columnEleNumbers=nullptr;
         }

         if(m_pool)
         {
             delete[] m_pool;
             m_pool=nullptr;
         }
         if(m_head)
         {
             delete[] m_head;
             m_head=nullptr;
         }
     }

 public:

     CDancingLinks():m_colNumber(-),m_rowNumber(-),
         m_columnEleNumbers(nullptr),m_pool(nullptr),m_head(nullptr) {}

     /***
       列下标为[1,Column]
     ***/
     CDancingLinks(const int Column,const int Row):
         m_columnEleNumbers(nullptr),m_pool(nullptr),m_head(nullptr)
     {
         SetSize(Column,Row);
     }

     /***
       列下标为[1,Column]
     ***/
     void SetSize(const int Column,const int Row)
     {
         m_colNumber=Column;
         m_rowNumber=Row;

         _ReleaseMemory();

         m_columnEleNumbers=new int[m_colNumber+];
         m_pool=new Node[m_colNumber*(m_rowNumber+)+];
         m_head=new Node*[m_rowNumber+];
         Clear();
     }

     void Clear()
     {
         for(int i=;i<=m_colNumber;++i)
         {
             Node* cur=_GetNode(i);
             cur->left=((i==m_colNumber)?_GetNode():_GetNode(i+));
             cur->right=((==i)?_GetNode(m_colNumber):_GetNode(i-));
             m_columnEleNumbers[i]=;

             cur->up=cur->down=_GetNode(i);
             cur->col=i;
             cur->row=;
         }
         for(int i=;i<=m_rowNumber;++i) m_head[i]=NULL;
         m_curUsePoolIndex=m_colNumber+;
     }

     ~CDancingLinks()
     {
         _ReleaseMemory();
     }

     void AddElement(const int row,const int col)
     {

         Node* cur=m_pool+(m_curUsePoolIndex++);

         cur->up=_GetNode(col);
         cur->down=_GetNode(col)->down;
         m_pool[col].down->up=cur;
         m_pool[col].down=cur;

         if(m_head[row]==NULL)
         {
             m_head[row]=cur->left=cur->right=cur;
         }
         else
         {
             cur->left=m_head[row]->left;
             cur->right=m_head[row];
             m_head[row]->left->right=cur;
             m_head[row]->left=cur;
         }
         ++m_columnEleNumbers[col];
         cur->col=col;
         cur->row=row;
     }

     bool GetSolution(std::vector<int> &Solution)
     {
         return _SearchSolution(,Solution);
     }
 };