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(0);
        if(p->left==p) return true;

        int Min=m_rowNumber+1;
        int MinColumnIndex=0;
        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+1,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(-1),m_rowNumber(-1),
        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+1];
        m_pool=new Node[m_colNumber*(m_rowNumber+1)+1];
        m_head=new Node*[m_rowNumber+1];
        Clear();
    }

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

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

    ~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(0,Solution);
    }
};