精确覆盖问题

最新推荐文章于 2023-04-27 18:30:19 发布
最新推荐文章于 2023-04-27 18:30:19 发布
阅读量1.1k 收藏 2
点赞数 1
分类专栏： 数据结构与算法 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39942341/article/details/126681667
版权

精确覆盖问题

精确覆盖问题(Exact Cover Problem),指给定许多集合 S i ( 1 ≤ i ≤ n ) S_i\left(1\le i\le n\right) Si​(1≤i≤n),
以及集合 X ⊂ S X\subset S X⊂S,求满足以下条件的无序多元组 ( T 1 , T 2 , ⋯   , T m ) \left(T_1,T_2,\cdots,T_m\right) (T1​,T2​,⋯,Tm​):

  1. ∀ i , j ∈ [ 1 , m ] , T i ∩ T j = ∅ ( i ≠ j ) \forall i,j\in\left[1,m\right],T_i\cap T_j = \empty\left(i\neq j\right) ∀i,j∈[1,m],Ti​∩Tj​=∅(i=j)
  2. X = ∪ i = 1 m T i X=\cup_{i=1}^{m} T_i X=∪i=1m​Ti​
  3. ∀ i ∈ [ 1 , m ] , T i ∈ { S 1 , ⋯   , S n } \forall i\in \left[1,m\right],T_i\in\left\{S_1,\cdots,S_n\right\} ∀i∈[1,m],Ti​∈{S1​,⋯,Sn​}

问题转化

( 0 0 1 0 1 1 0 1 0 0 1 0 0 1 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 ) \left(\begin{array}{lllllll} 0 & 0 & 1 & 0 & 1 & 1 & 0 \\ 1 & 0 & 0 & 1 & 0 & 0 & 1 \\ 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{array}\right) ⎝ ⎛​010100​001010​101000​010101​100001​101000​010011​⎠ ⎞​
行代表每一个集合，列代表每一个元素
那问题就转化为选择某几行，使得满足那些条件
如果暴力枚举，假设 m m m行 n n n列，时间复杂度 O ( n m ⋅ 2 n ) O\left(nm\cdot2^n\right) O(nm⋅2n)

X算法

其实和暴力没啥差别，就是枚举的时候删除对应行和对应列
比如选了第1行，则第3行和第6行就不能选了，进而转化为
( 1 0 1 1 1 0 1 0 0 1 0 1 ) \left(\begin{array}{llll} 1 & 0 & 1 & 1 \\ 1 & 0 & 1 & 0 \\ 0 & 1 & 0 & 1 \end{array}\right) ⎝ ⎛​110​001​110​101​⎠ ⎞​

舞蹈链

舞蹈链(Dancing Links)，其实就是X算法，用十字链表

十字链表定义

const int MAXN = 5505, M = 505, N = 505;
int left[MAXN], right[MAXN], up[MAXN], down[MAXN];//每个元素上下左右
int row[MAXN], col[MAXN];//每一个元素所在行和列
int head[M+5], col_size[N+5], cnt = 0;//每行第一个元素，每列元素个数，总元素个数

下面图均来自OI WIKI
在这里插入图片描述
记住下标从1开始，因为0相当于一个头
在这里插入图片描述

初始化

在这里插入图片描述
初始化需要初始化成这样

void init(const int& N) {
	for (int i = 0; i <= N; ++i) {
		left[i] = i - 1;
		right[i] = i + 1;
		up[i] = down[i] = i;
	}
	left[0] = N;
	right[N] = 0;
	memset(head, -1, sizeof(head));
	memset(col_size, 0, sizeof(col_size));
	cnt = N + 1;
}
插入元素

相对于列来说，这其实就是头插法，然后维护双向链表
对于行来说，就是插到head[r]的左边

记住下标从1开始

void link(const int& r, const int& c) {
	++col_size[c];
	row[cnt] = r;
	col[cnt] = c;
	up[cnt] = c;
	down[cnt] = down[c];
	up[down[c]] = cnt;
	down[c] = cnt;
	if (head[r] == -1) {
		head[r] = left[cnt] = right[cnt] = cnt;
	}
	else {
		right[cnt] = head[r];
		left[cnt] = left[head[r]];
		right[left[head[r]]] = cnt;
		left[head[r]] = cnt;
	}

	++cnt;
}
删除

删除c列，以及相关的行

先删除列，然后从上往下遍历，删除行

void remove(const int& c) {
	right[left[c]] = right[c];
	left[right[c]] = left[c];
	for (int i = down[c]; i != c; i = down[i]) {
		for (int j = right[i]; j != i; j = right[j]) {
			up[down[j]] = up[j];
			down[up[j]] = down[j];
			--col_size[col[j]];
		}
	}
}
恢复

反着跑一遍删除

void resume(const int& c) {
	for (int i = up[c]; i != c; i = up[i]) {
		for (int j = right[i]; j != i; j = right[j]) {
			up[down[j]] = j;
			down[up[j]] = j;
			++col_size[col[j]];
		}
	}
	right[left[c]] = c;
	left[right[c]] = c;
}
主程序

选择1最少的列，删除
遍历这一列，枚举是否选择这一行

这里注意恢复的时候一定要left

bool dance(int dep) {
	if (right[0] == 0) {
		return true;
	}
	int c = right[0];
	for (int i = right[c]; i != 0; i = right[i]) {
		if (col_size[i] < col_size[c]) {
			c = i;
		}
	}
	remove(c);
	for (int i = down[c]; i != c; i = down[i]) {
		ans_row[ans++] = row[i];
		for (int j = right[i]; j != i; j = right[j]) {
			remove(col[j]);
		}
		if (dance(dep + 1)) {
			return true;
		}
		for (int j = left[i]; j != i; j = left[j]) {
			resume(col[j]);
		}
		--ans;
	}
	resume(c);
	return false;
}
完整
#include<cstdio>
#include<cstring>

const int MAXN = 5505, M = 505, N = 505;
int left[MAXN], right[MAXN], up[MAXN], down[MAXN];
int row[MAXN], col[MAXN], head[M+5], col_size[N+5], cnt = 0;
int ans, ans_row[M];

void init(const int& N) {
	for (int i = 0; i <= N; ++i) {
		left[i] = i - 1;
		right[i] = i + 1;
		up[i] = down[i] = i;
	}
	left[0] = N;
	right[N] = 0;
	memset(head, -1, sizeof(head));
	memset(col_size, 0, sizeof(col_size));
	cnt = N + 1;
}
void link(const int& r, const int& c) {
	++col_size[c];
	row[cnt] = r;
	col[cnt] = c;
	up[cnt] = c;
	down[cnt] = down[c];
	up[down[c]] = cnt;
	down[c] = cnt;
	if (head[r] == -1) {
		head[r] = left[cnt] = right[cnt] = cnt;
	}
	else {
		right[cnt] = head[r];
		left[cnt] = left[head[r]];
		right[left[head[r]]] = cnt;
		left[head[r]] = cnt;
	}

	++cnt;
}

void remove(const int& c) {
	right[left[c]] = right[c];
	left[right[c]] = left[c];
	for (int i = down[c]; i != c; i = down[i]) {
		for (int j = right[i]; j != i; j = right[j]) {
			up[down[j]] = up[j];
			down[up[j]] = down[j];
			--col_size[col[j]];
		}
	}
}
void resume(const int& c) {
	for (int i = up[c]; i != c; i = up[i]) {
		for (int j = right[i]; j != i; j = right[j]) {
			up[down[j]] = j;
			down[up[j]] = j;
			++col_size[col[j]];
		}
	}
	right[left[c]] = c;
	left[right[c]] = c;
}

bool dance(int dep) {
	if (right[0] == 0) {
		return true;
	}
	int c = right[0];
	for (int i = right[c]; i != 0; i = right[i]) {
		if (col_size[i] < col_size[c]) {
			c = i;
		}
	}
	remove(c);
	for (int i = down[c]; i != c; i = down[i]) {
		ans_row[ans++] = row[i];
		for (int j = right[i]; j != i; j = right[j]) {
			remove(col[j]);
		}
		if (dance(dep + 1)) {
			return true;
		}
		for (int j = left[i]; j != i; j = left[j]) {
			resume(col[j]);
		}
		--ans;
	}
	resume(c);
	return false;
}

类版本

#include<cstdio>
#include<cstring>

const int M = 505, N = 505;
class DLX {
public:
	static const int MAXN = 5505;
	int left[MAXN], right[MAXN], up[MAXN], down[MAXN];
	int row[MAXN], col[MAXN], head[M+5], col_size[N+5], cnt;
	int ans, ans_row[M];
	DLX() :cnt(0), ans(0) {}
	void init(const int& N) {
		cnt = ans = 0;
		for (int i = 0; i <= N; ++i) {
			left[i] = i - 1;
			right[i] = i + 1;
			up[i] = down[i] = i;
		}
		left[0] = N;
		right[N] = 0;
		memset(head, -1, sizeof(head));
		memset(col_size, 0, sizeof(col_size));
		cnt = N + 1;
	}
	void link(const int& r, const int& c) {
		++col_size[c];
		row[cnt] = r;
		col[cnt] = c;
		up[cnt] = c;
		down[cnt] = down[c];
		up[down[c]] = cnt;
		down[c] = cnt;
		if (head[r] == -1) {
			head[r] = left[cnt] = right[cnt] = cnt;
		}
		else {
			right[cnt] = head[r];
			left[cnt] = left[head[r]];
			right[left[head[r]]] = cnt;
			left[head[r]] = cnt;
		}

		++cnt;
	}
	void remove(const int& c) {
		right[left[c]] = right[c];
		left[right[c]] = left[c];
		for (int i = down[c]; i != c; i = down[i]) {
			for (int j = right[i]; j != i; j = right[j]) {
				up[down[j]] = up[j];
				down[up[j]] = down[j];
				--col_size[col[j]];
			}
		}
	}
	void resume(const int& c) {
		for (int i = up[c]; i != c; i = up[i]) {
			for (int j = right[i]; j != i; j = right[j]) {
				up[down[j]] = j;
				down[up[j]] = j;
				++col_size[col[j]];
			}
		}
		right[left[c]] = c;
		left[right[c]] = c;
	}
	bool dance(int dep) {
		if (right[0] == 0) {
			return true;
		}
		int c = right[0];
		for (int i = right[c]; i != 0; i = right[i]) {
			if (col_size[i] < col_size[c]) {
				c = i;
			}
		}
		remove(c);
		for (int i = down[c]; i != c; i = down[i]) {
			ans_row[ans++] = row[i];
			for (int j = right[i]; j != i; j = right[j]) {
				remove(col[j]);
			}
			if (dance(dep + 1)) {
				return true;
			}
			for (int j = left[i]; j != i; j = left[j]) {
				resume(col[j]);
			}
			--ans;
		}
		resume(c);
		return false;
	}
};

洛谷P4929

https://www.luogu.com.cn/problem/P4929

#include<cstdio>
#include<cstring>

const int M = 505, N = 505;
class DLX {
public:
	static const int MAXN = 5505;
	int left[MAXN], right[MAXN], up[MAXN], down[MAXN];
	int row[MAXN], col[MAXN], head[M+5], col_size[N+5], cnt;
	int ans, ans_row[M];
	DLX() :cnt(0), ans(0) {}
	void init(const int& N) {
		cnt = ans = 0;
		for (int i = 0; i <= N; ++i) {
			left[i] = i - 1;
			right[i] = i + 1;
			up[i] = down[i] = i;
		}
		left[0] = N;
		right[N] = 0;
		memset(head, -1, sizeof(head));
		memset(col_size, 0, sizeof(col_size));
		cnt = N + 1;
	}
	void link(const int& r, const int& c) {
		++col_size[c];
		row[cnt] = r;
		col[cnt] = c;
		up[cnt] = c;
		down[cnt] = down[c];
		up[down[c]] = cnt;
		down[c] = cnt;
		if (head[r] == -1) {
			head[r] = left[cnt] = right[cnt] = cnt;
		}
		else {
			right[cnt] = head[r];
			left[cnt] = left[head[r]];
			right[left[head[r]]] = cnt;
			left[head[r]] = cnt;
		}

		++cnt;
	}
	void remove(const int& c) {
		right[left[c]] = right[c];
		left[right[c]] = left[c];
		for (int i = down[c]; i != c; i = down[i]) {
			for (int j = right[i]; j != i; j = right[j]) {
				up[down[j]] = up[j];
				down[up[j]] = down[j];
				--col_size[col[j]];
			}
		}
	}
	void resume(const int& c) {
		for (int i = up[c]; i != c; i = up[i]) {
			for (int j = right[i]; j != i; j = right[j]) {
				up[down[j]] = j;
				down[up[j]] = j;
				++col_size[col[j]];
			}
		}
		right[left[c]] = c;
		left[right[c]] = c;
	}
	bool dance(int dep) {
		if (right[0] == 0) {
			return true;
		}
		int c = right[0];
		for (int i = right[c]; i != 0; i = right[i]) {
			if (col_size[i] < col_size[c]) {
				c = i;
			}
		}
		remove(c);
		for (int i = down[c]; i != c; i = down[i]) {
			ans_row[ans++] = row[i];
			for (int j = right[i]; j != i; j = right[j]) {
				remove(col[j]);
			}
			if (dance(dep + 1)) {
				return true;
			}
			for (int j = left[i]; j != i; j = left[j]) {
				resume(col[j]);
			}
			--ans;
		}
		resume(c);
		return false;
	}
};
int main() {
	DLX solver;
	int m, n;
	scanf("%d%d", &m, &n);
	solver.init(n);
	for (int i = 1; i <= m; ++i) {
		for (int j = 1; j <= n; ++j) {
			int t;
			scanf("%d", &t);
			if (t == 1) {
				solver.link(i, j);
			}
		}
	}
	if (solver.dance(0)) {
		for (int i = 0; i < solver.ans; ++i) {
			if (i > 0) {
				printf(" ");
			}
			printf("%d", solver.ans_row[i]);
		}
		printf("\n");
	}
	else {
		printf("No Solution!\n");
	}
	return 0;
}

洛谷P1784

https://www.luogu.com.cn/problem/P1784

行：81个格子，有9个数字，所以需要729个
列： [ 81 ∗ 0 + 1 , 81 ] \left[81*0+1,81\right] [81∗0+1,81]用来记录这个数字填在了哪
[ 81 ∗ 1 + 1 , 81 ∗ 2 ] \left[81*1+1,81*2\right] [81∗1+1,81∗2]用来记录行的1-9
[ 81 ∗ 2 + 1 , 81 ∗ 3 ] \left[81*2+1,81*3\right] [81∗2+1,81∗3]用来记录列的1-9
[ 81 ∗ 3 + 1 , 81 ∗ 4 ] \left[81*3+1,81*4\right] [81∗3+1,81∗4]用来记录九宫格的1-9
总共需要324个

然后插入就是每一个格子枚举，如果这个格子已经填过了，那就不需要枚举

MAXN理论上开到 729 ∗ 4 + 324 + 1 + 1 729*4+324+1+1 729∗4+324+1+1就够了

#include<cstdio>
#include<cstring>

const int H = 9;
const int M = H * H * H, N = H * H * 4;
class DLX {
public:
	static const int MAXN = M * 4 + N + 5;
	int left[MAXN], right[MAXN], up[MAXN], down[MAXN];
	int row[MAXN], col[MAXN], head[MAXN], col_size[MAXN], cnt;
	int ans, ans_row[H*H];
	DLX() :cnt(0), ans(0) {}
	void init(const int& N) {
		cnt = ans = 0;
		for (int i = 0; i <= N; ++i) {
			left[i] = i - 1;
			right[i] = i + 1;
			up[i] = down[i] = i;
		}
		left[0] = N;
		right[N] = 0;
		memset(head, -1, sizeof(head));
		memset(col_size, 0, sizeof(col_size));
		cnt = N + 1;
	}
	void link(const int& r, const int& c) {
		++col_size[c];
		row[cnt] = r;
		col[cnt] = c;
		up[cnt] = c;
		down[cnt] = down[c];
		up[down[c]] = cnt;
		down[c] = cnt;
		if (head[r] == -1) {
			head[r] = left[cnt] = right[cnt] = cnt;
		}
		else {
			right[cnt] = head[r];
			left[cnt] = left[head[r]];
			right[left[head[r]]] = cnt;
			left[head[r]] = cnt;
		}

		++cnt;
	}
	void remove(const int& c) {
		right[left[c]] = right[c];
		left[right[c]] = left[c];
		for (int i = down[c]; i != c; i = down[i]) {
			for (int j = right[i]; j != i; j = right[j]) {
				up[down[j]] = up[j];
				down[up[j]] = down[j];
				--col_size[col[j]];
			}
		}
	}
	void resume(const int& c) {
		for (int i = up[c]; i != c; i = up[i]) {
			for (int j = right[i]; j != i; j = right[j]) {
				up[down[j]] = j;
				down[up[j]] = j;
				++col_size[col[j]];
			}
		}
		right[left[c]] = c;
		left[right[c]] = c;
	}
	bool dance(int dep) {
		if (right[0] == 0) {
			return true;
		}
		int c = right[0];
		for (int i = right[c]; i != 0; i = right[i]) {
			if (col_size[i] < col_size[c]) {
				c = i;
			}
		}
		remove(c);
		for (int i = down[c]; i != c; i = down[i]) {
			ans_row[ans++] = row[i];
			for (int j = right[i]; j != i; j = right[j]) {
				remove(col[j]);
			}
			if (dance(dep + 1)) {
				return true;
			}
			for (int j = left[i]; j != i; j = left[j]) {
				resume(col[j]);
			}
			--ans;
		}
		resume(c);
		return false;
	}
};
int main() {
	DLX solver;
	solver.init(N);
	int a[H][H];
	for (int i = 0; i < H; ++i) {
		for (int j = 0; j < H; ++j) {
			scanf("%d", &a[i][j]);
			for (int k = 1; k <= H; ++k) {
				if (a[i][j] == 0 || a[i][j] == k) {
					int idx = i * H * H + j * H + k;
					solver.link(idx, i * H + j + 1);
					solver.link(idx, H * H + i * H + k);
					solver.link(idx, H * H * 2 + j * H + k);
					solver.link(idx, H * H * 3 + (i / 3 * 3 + j / 3) * 9 + k);
				}
			}
		}
	}
	if (solver.dance(0)) {
		for (int i = 0; i < solver.ans; ++i) {
			int cur = solver.ans_row[i];
			int r = (cur - 1) / (H*H), c = (cur - 1) / H % H, k = (cur - 1) % 9 + 1;
			a[r][c] = k;
		}
		for (int i = 0; i < H; ++i) {
			for (int j = 0; j < H; ++j) {
				if (j > 0)printf(" ");
				printf("%d", a[i][j]);
			}
			printf("\n");
		}
	}
	return 0;
}

洛谷P1219

https://www.luogu.com.cn/problem/P1219

与上一题类似
行： n ∗ n n*n n∗n个格子
列： [ 1 , n ] \left[1,n\right] [1,n]用来记录这个数字填在了哪行
[ n + 1 , 2 n ] \left[n+1,2n\right] [n+1,2n]用来记录这个数字填在了哪列
[ 2 n + 1 , 4 n − 1 ] \left[2n+1,4n-1\right] [2n+1,4n−1]用来记录这个数字填在了哪条副对角线(从 ( 0 , 0 ) (0,0) (0,0)开始)
[ 4 n , 6 n − 2 ] \left[4n,6n-2\right] [4n,6n−2]用来记录这个数字填在了哪条主对角线(从 ( n − 1 , 0 ) (n-1,0) (n−1,0)开始)

但是注意一点，对角线是无法完全覆盖的
比如下面的图，第3条副对角线就没有覆盖
在这里插入图片描述
所以如果行和列覆盖完了就可以返回了

#include<cstdio>
#include<cstring>
#include<algorithm>

const int H = 13;
const int M = H * H, N = 6 * H - 2;
int n, board_cnt;
struct A {
	int a[H];
}board[100000];
bool cmp(const A& a, const A& b) {
	int i = 0;
	while (i < n && a.a[i] == b.a[i])++i;
	return a.a[i] < b.a[i];
};
class DLX {
public:
	static const int MAXN = M * 4 + N + 5;
	int left[MAXN], right[MAXN], up[MAXN], down[MAXN];
	int row[MAXN], col[MAXN], head[M+5], col_size[N+5], cnt;
	int ans, ans_row[H];
	DLX() :cnt(0), ans(0) {}
	void init(const int& N) {
		cnt = ans = 0;
		for (int i = 0; i <= N; ++i) {
			left[i] = i - 1;
			right[i] = i + 1;
			up[i] = down[i] = i;
		}
		left[0] = N;
		right[N] = 0;
		memset(head, -1, sizeof(head));
		memset(col_size, 0, sizeof(col_size));
		cnt = N + 1;
	}
	void link(const int& r, const int& c) {
		++col_size[c];
		row[cnt] = r;
		col[cnt] = c;
		up[cnt] = c;
		down[cnt] = down[c];
		up[down[c]] = cnt;
		down[c] = cnt;
		if (head[r] == -1) {
			head[r] = left[cnt] = right[cnt] = cnt;
		}
		else {
			right[cnt] = head[r];
			left[cnt] = left[head[r]];
			right[left[head[r]]] = cnt;
			left[head[r]] = cnt;
		}

		++cnt;
	}
	void remove(const int& c) {
		right[left[c]] = right[c];
		left[right[c]] = left[c];
		for (int i = down[c]; i != c; i = down[i]) {
			for (int j = right[i]; j != i; j = right[j]) {
				up[down[j]] = up[j];
				down[up[j]] = down[j];
				--col_size[col[j]];
			}
		}
	}
	void resume(const int& c) {
		for (int i = up[c]; i != c; i = up[i]) {
			for (int j = right[i]; j != i; j = right[j]) {
				up[down[j]] = j;
				down[up[j]] = j;
				++col_size[col[j]];
			}
		}
		right[left[c]] = c;
		left[right[c]] = c;
	}
	void dance(int dep) {
		if (right[0]>n) {
			for (int i = 0; i < n; ++i) {
				int x = (ans_row[i] - 1) / n;
				int y = (ans_row[i] - 1) % n + 1;
				board[board_cnt].a[x] = y;
			}
			++board_cnt;
			return;
		}
		int c = right[0];
		for (int i = right[c]; i != 0 && i <= n; i = right[i]) {
			if (col_size[i] < col_size[c]) {
				c = i;
			}
		}
		remove(c);
		for (int i = down[c]; i != c; i = down[i]) {
			ans_row[ans++] = row[i];
			for (int j = right[i]; j != i; j = right[j]) {
				remove(col[j]);
			}
			dance(dep + 1);
			for (int j = left[i]; j != i; j = left[j]) {
				resume(col[j]);
			}
			--ans;
		}
		resume(c);
		return;
	}
};
int main() {
	scanf("%d", &n);
	DLX solver;
	solver.init(6 * n - 2);
	for (int i = 0; i < n; ++i) {
		for (int j = 0; j < n; ++j) {
			int idx = i * n + j + 1;
			solver.link(idx, i + 1);
			solver.link(idx, n + j + 1);
			solver.link(idx, 2 * n + 1 + i + j);
			solver.link(idx, 4 * n + n + j - i - 1);
		}
	}
	solver.dance(0);
	std::sort(board, board + board_cnt, cmp);
	for (int i = 0; i < 3; ++i) {
		for (int j = 0; j < n; ++j) {
			if (j > 0)printf(" ");
			printf("%d", board[i].a[j]);
		}
		printf("\n");
	}
	printf("%d\n", board_cnt);
	return 0;
}

参考：
https://oi-wiki.org/search/dlx/

精确覆盖问题、Algorithm X 与 Dancing Links（DLX）
继科杂货店
01-07 3834
精确覆盖（Exact Cover）问题 精确覆盖 S 为集合 X 的若干个子集构成的集合，若存在 S 的一个子集 S*，满足 X 中的元素有且只有一次包含在 S* 的一个元素中，那么称 S* 为 X 的一个精确覆盖。 S*属性 根据定义 S* 具有以下属性： 1. S* 中任意两个元素交集为空。 2. S* 中所有元素并集为 X。 例子 假定 S = { A, B, C
DLX_精确覆盖问题
sluqy671的专栏
01-05 1316
精确覆盖问题： 给定一个由0-1组成的矩阵， 问是否能找到一个行的集合， 使得集合中每一列都恰好包含一个1
Dancing Link --- 模板题 HUST 1017 - Exact cover
weixin_33674976的博客
04-14 139
 1017 - Exact cover Problem's Link:   http://acm.hust.edu.cn/problem/show/1017   Mean:  给定一个由0-1组成的矩阵，是否能找到一个行的集合，使得集合中每一列都恰好包含一个1   analyse: 初学DLX。 这是DLX处理的最简单的问题，也是模板题。 Time complexity: O...
【HUST - 1017】精确覆盖问题 Exact Cover DLX 解题报告
07-11 287
Exact cover Time Limit:15000MS Memory Limit:131072KB 64bit IO Format:%lld & %llu Description There is an N*M matrix with only 0s and 1s, (1 <= N,M &...
DLX精确覆盖问题
GROZAX的博客
04-27 307
铃兰小姐邀请您来一起学习舞蹈～链算法！快点进来和铃兰一起学习吧！
精确覆盖问题和DLX算法.ppt
07-14
集覆盖问题研究满足覆盖所有需求点顾客的前提下，服务站总的建站个数或建设费用最小的问题。集覆盖问题最早是由 Roth和 Toregas等提出的，用于解决消防中心和救护车等的应急服务设施的选址问题，他们分别建立了服务...
瓷砖装配模型中最小和精确覆盖问题的分子解决方案
03-19
《瓷砖装配模型中最小和精确覆盖问题的分子解决方案》这篇研究论文主要探讨了如何利用生物计算模型——瓷砖装配模型（Tile Assembly Model, TAM）来解决NP完全问题中的最小覆盖问题和精确覆盖问题。瓷砖装配模型是一...
Pentomino-tiling:递归解决pentomino精确覆盖问题
05-12
递归解决pentomino精确覆盖问题。 戊糖基是由5个正方形组成的聚糖基。 如果不计算旋转和反射，则有12种五角形形状。 大多数戊米诺骨牌可以通过旋转形成自己的镜像，但是其中一些必须翻转。 I L N Y FF I L NN PP...
Sudoku (数独)和精确覆盖
03-24
数独可以看作是一个特殊的精确覆盖问题，因为每个数字相当于集合的一个元素，而每个位置则对应一个子集，需要找到一个解决方案使得每个数字在特定的行、列和小宫格中出现且仅出现一次。 在数独求解算法中，一种常见...
精确覆盖问题学习笔记(三)——算法的初步实现
laomai的专栏
06-13 1931
一、类CExactCoverSolution的声明 #include #include #include #include using namespace std; //类型的定义 typedef int ELEMENT_TYPE; typedef char SUBSET_NAME; typedef vector ROW; typedef vector MATRIX;
精确覆盖问题学习笔记(二)——基本算法
laomai的专栏
06-11 1782
一、算法的主要流程 有了子集的矩阵表达形式之后，我们就可以用Knuth发明的X算法来求出精确覆盖问题的解。（如果你在研究算法，但是没听过knuth的名字并且你又不是计算机的天才的话，请在阅读完本文后立刻去拜读Knuth的大作，呵呵）。 这个递归算法（设算法函数的名字为search）的主要流程是 1、设置一个子集编号集合S,用来存储本次得到的部分解。开始时S为空。 2、判断当前矩阵M是否为空
精确覆盖问题学习笔记(五)——优化算法的实现代码
laomai的专栏
06-18 2100
//文件node.h #pragma once struct CNode { CNode* Left; //左节点指针 CNode* Right; //右节点指针 CNode* Up; //上节点指针,对列节点，则为本列最后一个元素的指针 CNode* Down; //下节点指针,对列节点，则为本列第一个元素的指针 int name;
舞蹈链（Dancing Links）算法 —— 求精确覆盖问题
qq_52317884的博客
01-30 2014
精确覆盖问题： 给定一个由0、1组成的矩阵，是否能找到一个行的集合，使得集合中每一列恰好包含一个1。 这类问题就是经典的精确覆盖问题，没有多项式算法，属于NP完全问题。 回溯穷举： 选择第一行(红色)，同一列中有1会与之冲突的元素用蓝色标识出来。 从列看下去，同样有1的使用蓝色标识的这些行不能选择，用绿色标识。 选择了第一行红色后，蓝色与绿色不予考虑，那么将红色记录，将红蓝绿删除后，问题简化。 继续用同样的方式求解这个小规模矩阵。 再次缩小问题规模，删除完后剩下的矩阵变成了空矩阵。
POJ 3740 Easy Finding (Exact cover problem)
weixin_34218579的博客
08-08 101
Basic and obvious exact cover problem, using Dancing Links Algorithm (DLX). DLX reference: Dancing Links.pdf #include <stdio.h> const int MAXM = 20; const int MAXN = 400; int U[MAXM...
精确覆盖问题的回溯算法(一)——问题描述
laomai的专栏
06-11 3527
一、问题描述 精确覆盖问题(Exact Cover Problem)，是指给定了一个全集S以及它的m个子集S1、S2、..Sm以后，要求出一组子集，使这组子集的并等于原来的全集S，且各子集两两不交。 例：设 S={1,2,3,4,5,6,7}, A={1,4,7}, B={1,4}, C={4,5,7}, D={3,5,6}, E={2,3,6,7} ,F={2,7} 则子集组
HUST 1017 Exact cover（Dancing Links）（精确覆盖问题）
piaocoder
01-18 729
题目链接： http://acm.hust.edu.cn/problem/show/1017 解题思路： 题目大意： 本题就是给你一个由0，1元素组成的矩阵，问取出哪几行，可以使这几行构成的新矩阵，每列只有一个1. 算法思想： Dancing Links模板题。 如果有人还不了解双向链表的人可以先看一下这位大牛的博客：http://blog.sina.com.cn/s/blo
poj3074 Sudoku【DLX】【数独】【精确覆盖问题】
weixin_43499182的博客
05-06 244
题目链接：http://poj.org/problem?id=3074 大佬题解链接：https://www.cnblogs.com/ylfdrib/archive/2010/10/06/1844559.html AC代码： #include<iostream> #include<cstdio> #include<cstdlib> #include<cma...
Exact cover（HUST1017)
谢聪的专栏
09-20 521
直接贴代码吧咯，这个问题的规模1000*1000的精确覆盖，普通的数据结构过不去了，要用dlx了，除了dlx我没想出来其它的解法，（PS:这是抢来的模板） /************************************************ Author :xiecong Created Time :2015/9/20 22:55:25 File Name
算法与数据结构-精确覆盖
倚风语的专栏
12-23 1303
在一个全集X中若干子集的集合为S，精确覆盖（Exact cover）是指，S的子集S*，满足X中的每一个元素在S*中恰好出现一次。[1] 在计算机科学中，精确覆盖问题指找出这样的一种覆盖，或证明其不存在。这是一个NP-完全问题[1]，也是卡普的二十一个NP-完全问题之一[2]。 定义 满足以下条件的集合为一个精确覆盖： S*中任意两个集合没有交集，即X中的元素在S*中出现最多一次S*中
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Nightmare004

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值