2. 程式人生 > 實用技巧 >[學習筆記]舞蹈鏈(DLX)(C++指標版)

[學習筆記]舞蹈鏈(DLX)(C++指標版)

阿新 • • 發佈：2020-12-03

概述

舞蹈鏈(Dancing Links X)是一種能較高效地解決精確覆蓋問題的暴力演算法

模板題：洛谷P4929

精確覆蓋問題

精確覆蓋問題是這樣一類問題：

給定一個01矩陣，要求選出其中一些行，使得這些行組成的新矩陣每一列恰好有一個1

例如

對於矩陣

\[\left( \begin{matrix} 0 & 0 & 1 & 0 & 1 & 1 & 0 \\ 1 & 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 1 & 1 & 0 & 0 & 1 & 0 \\ 1 & 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 1 & 1 & 0 & 1 \end{matrix} \right) \]

一組解為1,4,5行

層層深入

基本暴力

列舉所有行組合，然後檢驗

顯然會T到飛起

稍作思考的暴力(X演算法)

假設我們選了一行，那麼與這行有重疊部分的行就不能選了，我們將其刪除

同時，我們把已經被覆蓋的列也刪除

原問題就變成了規模更小的精確覆蓋問題

如果最後沒有辦法覆蓋某一列，就更改之前的操作，繼續暴力

直到最後所有列被覆蓋(找到一組解)或是始終有某些列不能被覆蓋(無解)

以上面的矩陣為例，我們先選擇第1行，刪去這一行和與它有重合部分的行，把已經覆蓋的列也刪去，得到

\[\left( \begin{matrix} 1&0&1&1 \\ 1&0&1&0 \\ 0&1&0&1 \end{matrix} \right) \]

接下來問題變成了一個規模更小的精確覆蓋問題

假設我們再選擇第1行，得到

\[\left( \begin{matrix} 1&1 \end{matrix} \right ) \]

再選第1行，得到空矩陣

說明找到一組解

回顧過程，我們依次刪掉了原矩陣的1,4,5行

Donald E. Knuth大師的暴力

下面的圖片均來自: https://www.cnblogs.com/grenet/p/3145800.html

上面的稍作思考的暴力複雜度依然很高

為什麼複雜度會很高呢？

我們發現有大量時間花費在對矩陣的修改上

那麼有沒有辦法降低修改矩陣的時間開銷呢？

當然是有的，Donald E. Knuth大師給出瞭解決方案——交叉十字迴圈雙向鏈

首先由於我們只關心覆蓋，所以只考慮1的位置，0就可以丟掉啦

把1的位置像下面這張圖一樣存起來：

對應矩陣

\[\left( \begin{matrix} 0 & 0 & 1 & 0 & 1 & 1 & 0 \\ 1 & 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 1 & 1 & 0 & 0 & 1 & 0 \\ 1 & 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 1 & 1 & 0 & 1 \end{matrix} \right) \]

其中第一行的head是整個連結串列的入口，C1,C2,...是各列的入口

接下來我們來看看具體操作

連結串列構建

首先是連結串列元素的結構體

struct Node {
	Node *left, *right, *up, *down, *head; //指向四個方向和列的表頭
	int row, cnt; //記錄列表及列元素個數
} *head, *cols[MAXN];

其中cnt只有C1,C2,...的有用，和一個優化有關 ，不加也慢不了多少（少過兩個點而已）

構建連結串列的過程

head = new Node;
for (int i = 0; i < m; ++i) {
	cols[i] = new Node;
	cols[i]->row = -1;
	cols[i]->head = cols[i];
}
for (int i = 1; i < m; ++i) cols[i]->left = cols[i - 1];
for (int i = m - 2; i >= 0; --i) cols[i]->right = cols[i + 1];
cols[0]->left = head, head->right = cols[0];
cols[m - 1]->right = head, head->left = cols[m - 1];

Node *p[MAXN]; //記錄列尾
for (int i = 0; i < m; ++i) p[i] = cols[i];
for (int i = 0; i < n; ++i) {
	Node *nplast = NULL;
	for (int j = 0; j < m; ++j)
		if (mtx[i][j]) {
			Node *np = new Node;
			np->row = i;
			//插入列中
			np->up = p[j], p[j]->down = np;
			np->down = p[j]->head, p[j]->head->up = np;
			np->head = p[j]->head;
			
			//插入行中
			if (nplast) {
				np->right = nplast->right;
				nplast->right->left = np;
				np->left = nplast, nplast->right = np;
			} else {
				np->left = np->right = np;
				nplast = np;
			}
			p[j] = np;
			++np->head->cnt;
		}

}
選定行

選定某一行時，對照第二種暴力，我們要刪去的有：這一行、這一行能覆蓋的列、與這一行有重疊部分的其它行

比如選定第二行來覆蓋第一列，那麼我們要刪掉下圖中的紫色節點

然後刪除已經覆蓋的列和能覆蓋它們的其它行，即下圖中的橙色節點

最後得到

程式碼如下

// p為要選擇的行的某個元素
for (Node *pp = p->right; pp != p; pp = pp->right) { //找到相關的列
	for (Node *ppc = pp->down; ppc != pp; ppc = ppc->down) { // 能覆蓋相關列的行
		if (ppc != pp->head)
			for (Node *ppr = ppc->right; ppr != ppc; ppr = ppr->right) {
				ppr->up->down = ppr->down, ppr->down->up = ppr->up;
				--ppr->head->cnt;
			}
	}
	pp->head->left->right = pp->head->right;
	pp->head->right->left = pp->head->left;
}
for (Node *ppc = p->down; ppc != p; ppc = ppc->down) {
	if (ppc != p->head)
		for (Node *ppr = ppc->right; ppr != ppc; ppr = ppr->right) {
			ppr->up->down = ppr->down, ppr->down->up = ppr->up;
			--ppr->head->cnt;
		}
}
p->head->left->right = p->head->right;
p->head->right->left = p->head->left;
撤銷

就是上面的選行的逆操作

for (Node *pp = p->right; pp != p; pp = pp->right) { //相關的列
	for (Node *ppc = pp->down; ppc != pp; ppc = ppc->down) { //包含相關列的行
		if (ppc != pp->head)
			for (Node *ppr = ppc->right; ppr != ppc; ppr = ppr->right) {
				ppr->up->down = ppr->down->up = ppr;
				++ppr->head->cnt;
			}
	}
	pp->head->left->right = pp->head->right->left = pp->head;
}
for (Node *ppc = p->down; ppc != p; ppc = ppc->down) {
	if (ppc != p->head)
		for (Node *ppr = ppc->right; ppr != ppc; ppr = ppr->right) {
			ppr->up->down = ppr->down->up = ppr;
			++ppr->head->cnt;
		}
}
p->head->left->right = p->head->right->left = p->head;
關於前面提到的優化

每次嘗試覆蓋某一列的時候，我們找剩餘元素最少的那列覆蓋

這樣可以優化一下時間

完整的程式碼：

// luogu P4929
#include <cstdio>
#include <cstring>
#include <iostream>

const int MAXN = 1010;

struct Node {
	Node *left, *right, *up, *down, *head; //指向四個方向和列的表頭
	int row, cnt; //記錄列表及列元素個數
} *head, *cols[MAXN];

int mtx[MAXN][MAXN], n, m;
int ans[MAXN], top;

void init();
bool solve();

int main() {
	scanf("%d%d", &n, &m);
	for (int i = 0; i < n; ++i)
		for (int j = 0; j < m; ++j)
			scanf("%d", &mtx[i][j]);
	init();
	if (solve()) {
		//puts("One solution found:");
		for (int i = 0; i < top; ++i) printf("%d ", ans[i] + 1);
		puts("");
	} else puts("No Solution!");


	return 0;
}
void init() {
	top = 0;
	head = new Node;
	for (int i = 0; i < m; ++i) {
		cols[i] = new Node;
		cols[i]->row = -1;
		cols[i]->head = cols[i];
	}
	for (int i = 1; i < m; ++i) cols[i]->left = cols[i - 1];
	for (int i = m - 2; i >= 0; --i) cols[i]->right = cols[i + 1];
	cols[0]->left = head, head->right = cols[0];
	cols[m - 1]->right = head, head->left = cols[m - 1];
	
	Node *p[MAXN]; //記錄列尾
	for (int i = 0; i < m; ++i) p[i] = cols[i];
	for (int i = 0; i < n; ++i) {
		Node *nplast = NULL;
		for (int j = 0; j < m; ++j)
			if (mtx[i][j]) {
				Node *np = new Node;
				np->row = i;
				//插入列中
				np->up = p[j], p[j]->down = np;
				np->down = p[j]->head, p[j]->head->up = np;
				np->head = p[j]->head;
				
				//插入行中
				if (nplast) {
					np->right = nplast->right;
					nplast->right->left = np;
					np->left = nplast, nplast->right = np;
				} else {
					np->left = np->right = np;
					nplast = np;
				}
				p[j] = np;
				++np->head->cnt;
			}

	}
}
bool solve() {
	if (head->right == head) return 1; //還有列未被覆蓋

	// 找到元素個數最少的列，能有效降低複雜度
	Node *c = head->right;
	for (Node *p = c->right; p != head; p = p->right)
		if (p->cnt < c->cnt) c = p;
	
	for (Node *p = c->down; p != c; p = p->down) {//列舉選擇的行
		for (Node *pp = p->right; pp != p; pp = pp->right) { //相關的列
			for (Node *ppc = pp->down; ppc != pp; ppc = ppc->down) { //包含相關列的行
				if (ppc != pp->head)
					for (Node *ppr = ppc->right; ppr != ppc; ppr = ppr->right) {
						ppr->up->down = ppr->down, ppr->down->up = ppr->up;
						--ppr->head->cnt;
					}
			}
			pp->head->left->right = pp->head->right;
			pp->head->right->left = pp->head->left;
		}
		for (Node *ppc = p->down; ppc != p; ppc = ppc->down) {
			if (ppc != p->head)
				for (Node *ppr = ppc->right; ppr != ppc; ppr = ppr->right) {
					ppr->up->down = ppr->down, ppr->down->up = ppr->up;
					--ppr->head->cnt;
				}
		}
		p->head->left->right = p->head->right;
		p->head->right->left = p->head->left;

		// 記錄答案，繼續搜尋
		ans[top++] = p->row;
		if (solve()) return 1;
		--top;

		// 撤銷選擇行的操作
		for (Node *pp = p->right; pp != p; pp = pp->right) { //相關的列
			for (Node *ppc = pp->down; ppc != pp; ppc = ppc->down) { //包含相關列的行
				if (ppc != pp->head)
					for (Node *ppr = ppc->right; ppr != ppc; ppr = ppr->right) {
						ppr->up->down = ppr->down->up = ppr;
						++ppr->head->cnt;
					}
			}
			pp->head->left->right = pp->head->right->left = pp->head;
		}
		for (Node *ppc = p->down; ppc != p; ppc = ppc->down) {
			if (ppc != p->head)
				for (Node *ppr = ppc->right; ppr != ppc; ppr = ppr->right) {
					ppr->up->down = ppr->down->up = ppr;
					++ppr->head->cnt;
				}
		}
		p->head->left->right = p->head->right->left = p->head;
	}
	return 0;
}
//Rhein_E

相關推薦

[學習筆記]舞蹈鏈(DLX)(C++指標版)

概述 舞蹈鏈(Dancing Links X)是一種能較高效地解決精確覆蓋問題的暴力演算法 模板題：洛谷P4929

Xlua學習筆記一——Lua對映c#生命週期函式

技術標籤：XLualuaunity 思路非常簡單，在c#指令碼中每個生命週期函式中執行一個事件，該事件用於在lua中呼叫，然後再寫一個新增或者刪除事件的函式即可。

資料結構學習筆記001-String類(C++)

string類包含於標頭檔案string中，使用string型別前需要新增標頭檔案string並使用名為std的名稱空間。

TCP/IP協議學習筆記2----鏈路層

1、資料鏈路層三個目的: 1）為IP模組傳送和接收IP資料報； 2）為ARP模組傳送ARP請求和接收ARP應答；

學習筆記——樹鏈剖分

樹鏈剖分學習筆記 思想 對於每個節點，把所有子節點中子樹最大的一個，成為重點，其它成為輕點。重點到父親節點的連線成為重邊，重邊連線成若干條重鏈，其餘的每個點稱為重鏈。

C++的智慧指標學習筆記(初)

C++ primer plus 16.2節介紹了auto_ptr，該模板類在C++11中已棄用，目前已被shared_ptr代替。

學習筆記：舞蹈鏈 Dancing Links

這是一種奇妙的演算法用來解決兩個問題： 精確覆蓋問題：給定一個矩陣，每行是一個二進位制數，選出儘量少的行，使得每一列恰好有一個 \\(1\\)

題解 P3377 配對堆（無指標版）學習筆記

對於一個學不懂高深演算法的小蒟蒻來說，這種暴力解法怎麼能不學呢。 可惜題解中的配對堆都實用了指標，這使得像我這樣的無指標選手非常頭疼。

C#設計模式學習筆記：(20)職責鏈模式

技術標籤：C#教程c# 本筆記摘抄自：https://www.cnblogs.com/PatrickLiu/p/8109100.html，記錄一下學習過程以備後續查用。

【C語言學習筆記】指標

技術標籤：學習筆記c語言指標 今天看了學習指標的視訊，記錄一下。 int *p; int a; *p是取值，&a是取地址。

《C程式設計語言》學習筆記（05）指標與陣列

技術標籤：C語言c語言指標陣列 目錄 第5章 指標與陣列5.1 指標與地址5.2 指標與函式引數【將輸入的下一個整型數賦值給 *pn】5.3 指標與陣列5.4 地址算數運算【字串長度】5.5 字元指標與函式【字串複製比較】5.

[c++學習筆記]指標與引用的區別

技術標籤：C++學習c++指標 引用是c++對c語言的功能補充。 引用和取地址的區別：只有在資料型別後的&才是引用宣告。

C++學習筆記 this指標，物件陣列，物件指標陣列；

一，this指標 this指標不是物件的一部分，this指標所佔的記憶體大小是不會反應在sizeof操作符上的，this指標的型別取決與使用this指標的成員函式型別以及物件型別

大一C語言學習筆記（9）---指標篇--從”記憶體的使用“和“流程控制”的角度來理解“指標變數的使用‘

總結：在指標變數沒有初始化的時候，使用“ * 指標變數 ”是錯誤的，這就和其他型別變數沒有初始化是一個型別的問題；對於指標變數來說，有沒有初始化不取決於它指向的記憶體中有沒有儲存資料，而取決於它有沒有儲

【C語言學習筆記】指標函式與函式指標

C語言中的函式和指標的概念是非常重要的概念，然後又讓人覺得非常困難。 本文來簡單聊一聊指標函式與函式指標的區別。

C++ 學習筆記 —— 指標

1、指標的基本概念 作用： 可以通過指標間接訪問記憶體 記憶體編號是從0開始記錄的，一般用十六進位制數字表示 可以利用指標變數儲存地址

C學習筆記（2）--指標

一、多檔案結構總結 1.子原始檔裡面包含自己對應的標頭檔案 2.無論是何原始檔呼叫庫函式，都需要包含該庫函式的宣告所在的標頭檔案

《C和指標》學習筆記[第二章 基本概念]

2.7問題 1.無法通過編譯，適配最後第一個*/，後面那個無法適配 2.優點的話，管理比較方便，各個函式衝突少。缺點，任何修改需要重新編譯整個原始檔，費時間。

《C和指標》學習筆記[第四章 語句]

4.13問題 1. 它是合法的，執行了加減乘除操作，但沒有賦值 2. x =  expression 3. 合法

C++中隱式型別轉換學習筆記

1 operator隱式型別轉換 1.1 std::ref原始碼中reference_wrapper隱式型別轉換 在std::ref的實現中有如下一段程式碼：