【POJ1084】Square Destroyer 重复覆盖问题 DLX(Dancing Links)

最新推荐文章于 2024-03-31 11:03:00 发布
原创 最新推荐文章于 2024-03-31 11:03:00 发布 · 2.5k 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#POJ1084 #Dancing Links #DLX #重复覆盖问题 #题解
博客介绍了如何使用Dancing Links (DLX) 算法解决POJ1084问题，即在火柴拼成的网格中删除最少的火柴以破坏所有正方形。将问题转化为DLX模型，每行代表火柴，每列代表正方形。通过DLX模板实现重复覆盖问题的求解，强调在重复覆盖问题中，不需要删除与行元素相关的列，因为不需要避免重复。文章提供了关键代码片段帮助读者快速理解和解决此问题。

    首先给一个传送门，是我写的精确覆盖问题，也是DLX。

    http://blog.csdn.net/vmurder/article/details/40586647

    然后再给一个传送门，是这道题的POJ位置。

    http://poj.org/problem?id=1084

    然后开始说正事。

题意：

    多组数据，第一个数是数据个数。

    题意就是给出一个n*n的大网格，然后它由一系列的火柴拼成，题中给的图片是第二组测试数据。

    现在我们已经删掉了若干个火柴，问至少还需要删掉多少火柴，才能使图中的若干个正方形全部被破坏。

解析：

    每个正方形都需要有其上的至少一根火柴被选，那么就转化成了DLX模型。每行是一跟火柴，每列是一个正方形，当然正方形个数是<=5*5+4*4+3*3+2*2+1*1=55的，然后显然若某行这根火柴在某列的正方形中，则new一个节点。这样就可以直接套DLX模版（重复覆盖的模版）求解了。

题解：

    跟简单覆盖基本一样，但是深刻理解一下就可以知道，简单覆盖时删除操作是先删列，然后枚举行，跟行有关的列也删掉，每深一层都是经过两次（好吧，你说是一次+for（若干次）我也同意）删除操作。

    而为什么要删除列呢？可以理解为剪枝，行呢？用过了。那跟行中元素有关的列呢？既然是精确覆盖，就不能有重复，那么自然就都删掉了，同时，“跟行中元素有关的列”中的元素的所在行因为避免重复就也被删掉了。

    而这个重复覆盖问题因为不需要“精确”，所以“跟行中元素有关的列”中的元素虽然需要删，可是这些元素（节点）的所在行，也就是这些根火柴，就不需要删了！

    这道题的精髓说完了，来说些糟粕吧，就是根本不需要会，但是不会却不能A的烦人细节。

    这么烦人我为什么要说？直接上代码！（火柴与方格间的连接及顺序等等，不用自己想，直接把我的复制过去就行了！）

	inline void build()
	{
		init();
		int i,j,k,n,m;
		int nmrx=0,npon=0;
		scanf("%d%d",&n,&m);
		memset(destroy,0,sizeof(destroy));
		memset(map,0,sizeof(map));
		for(k=0;k<n;k++)for(i=1;i+k<=n;i++)for(j=1;j+k<=n;j++)id[k][i][j]=++nmrx;
		for(i=1;i<=n;i++)
		{
			for(j=1;j<=n;j++)eid[0][i][j]=++npon;
			for(j=1;j<=n+1;j++)eid[1][i][j]=++npon;
		}
		for(i=1;i<=n;i++)eid[0][n+1][i]=++npon;
		for(k=0;k<n;k++)
			for(i=1;i+k<=n;i++)
				for(j=1;j+k<=n;j++)
				{
					int A=id[k][i][j],temp;
					for(temp=j;temp<=j+k;temp++)map[A][eid[0][i][temp]]=map[A][eid[0][i+k+1][temp]]=1;
					for(temp=i;temp<=i+k;temp++)map[A][eid[1][temp][j]]=map[A][eid[1][temp][j+k+1]]=1;
				}
		for(i=1;i<=m;i++)
		{
			scanf("%d",&k);
			for(j=1;j<=nmrx;j++)if(map[j][k])destroy[j]=1;
		}
		for(i=1;i<=nmrx;i++)if(!destroy[i])
		{
			U[i]=D[i]=i;
			L[i]=L[0],R[i]=0;
			L[0]=R[L[0]]=i;
		}
		cnt=nmrx;
		for(i=1;i<=nmrx;i++)
			if(!destroy[i])
				for(j=1;j<=npon;j++)
					if(map[i][j])
						newnode(j,i);
	}

真是恶心。DLX早早就写好了，这个乱七八糟的东西因为三次漏题重写了四次。

快来粘一发，然后快速水过此题吧。


好了，贴完整代码。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define N 60//55个格子
#define M 70//60个火柴
#define NN 300//每个格子4根火柴，算上辅助是5
#define inf 0x3f3f3f3f
using namespace std;
/*60火柴，25格*/
int ans;
struct DLX
{
	int U[NN],D[NN],L[NN],R[NN],C[NN];
	int H[M],T[N],cnt;
	inline void init()
	{
		cnt=0;
		memset(U,0,sizeof(U));
		memset(D,0,sizeof(D));
		memset(L,0,sizeof(L));
		memset(R,0,sizeof(R));
		memset(C,0,sizeof(C));
		memset(H,0,sizeof(H));
		memset(T,0,sizeof(T));
	}
	inline void newnode(int x,int y)
	{
		C[++cnt]=y;T[y]++;

		if(!H[x])H[x]=L[cnt]=R[cnt]=cnt;
		else L[cnt]=H[x],R[cnt]=R[H[x]];
		R[H[x]]=L[R[H[x]]]=cnt,H[x]=cnt;

		U[cnt]=U[y],D[cnt]=y;
		U[y]=D[U[y]]=cnt;
	}
	int id[N][N][5],eid[2][7][7];
	bool destroy[N],map[N][M];
	inline void build()
	{
		init();
		int i,j,k,n,m;
		int nmrx=0,npon=0;
		scanf("%d%d",&n,&m);
		memset(destroy,0,sizeof(destroy));
		memset(map,0,sizeof(map));
		for(k=0;k<n;k++)for(i=1;i+k<=n;i++)for(j=1;j+k<=n;j++)id[k][i][j]=++nmrx;
		for(i=1;i<=n;i++)
		{
			for(j=1;j<=n;j++)eid[0][i][j]=++npon;
			for(j=1;j<=n+1;j++)eid[1][i][j]=++npon;
		}
		for(i=1;i<=n;i++)eid[0][n+1][i]=++npon;
		for(k=0;k<n;k++)
			for(i=1;i+k<=n;i++)
				for(j=1;j+k<=n;j++)
				{
					int A=id[k][i][j],temp;
					for(temp=j;temp<=j+k;temp++)map[A][eid[0][i][temp]]=map[A][eid[0][i+k+1][temp]]=1;
					for(temp=i;temp<=i+k;temp++)map[A][eid[1][temp][j]]=map[A][eid[1][temp][j+k+1]]=1;
				}
		for(i=1;i<=m;i++)
		{
			scanf("%d",&k);
			for(j=1;j<=nmrx;j++)if(map[j][k])destroy[j]=1;
		}
		for(i=1;i<=nmrx;i++)if(!destroy[i])
		{
			U[i]=D[i]=i;
			L[i]=L[0],R[i]=0;
			L[0]=R[L[0]]=i;
		}
		cnt=nmrx;
		for(i=1;i<=nmrx;i++)
			if(!destroy[i])
				for(j=1;j<=npon;j++)
					if(map[i][j])
						newnode(j,i);
	}
	inline void remove(int x)
	{
		int i=x;
		do{
			R[L[i]]=R[i];
			L[R[i]]=L[i];
			i=D[i];
		}while(i!=x);
	}
	inline void resume(int x)
	{
		int i=x;
		do{
			R[L[i]]=i;
			L[R[i]]=i;
			i=U[i];
		}while(i!=x);
	}
	inline void dfs(int x)
	{
		if(x>=ans)return ;
		if(!R[0])
		{
			ans=x;
			return ;
		}
		int S=R[0],W=T[S],i,j;
		int del[N],num;
		for(i=R[S];i;i=R[i])if(T[i]<W)
		{
			W=T[i];
			S=i;
		}
		remove(S);
		for(i=D[S];i!=S;i=D[i])
		{
			del[num=1]=R[i];
			for(j=R[R[i]];j!=R[i];j=R[j])del[++num]=j;
			for(j=1;j<=num;j++)remove(del[j]);
			dfs(x+1);
			for(j=num;j;j--)resume(del[j]);
		}
		resume(S);
		return ;
	}
}dlx;
int main()
{
//	freopen("test.in","r",stdin);
//	freopen("my.out","w",stdout);
	int g;
	scanf("%d",&g);
	while(g--)
	{
		ans=inf;
		dlx.build();
		dlx.dfs(0);
		printf("%d\n",ans);
	}
	return 0;
}


POJ1084 Square Destroyer IDA*
Kevin的博客
09-11 330
题目链接 http://poj.org/problem?id=1084 分析 用IDA*做，每次找出一个最小的正方形，枚举删去哪条边，继续搜索下去； 对于每个正方形，删去哪条边最优并不知道，但如果单次操作删去所有边，则结果一定不大于未来的正常操作次数。 以此作为估价函数，此题要处理出火柴的编号，每根火柴对应的正方形，及每个正方形对应的火柴。 AC代码 #include <cstdio>...
POJ - 1084 Square Destroyer（IDA*算法）
00后的博客
01-18 584
POJ - 1084 Square Destroyer #include <cstdio> #include <cstring> #include <vector> using namespace std; const int N = 61; // 网格最大是 5 * 5 的，其中最多会有 5 * (5 + 1) * 2 = 60 个正方形，所以要开到 61 int n, idx; // n 为网格规模，idx 为正方形数量 int
POJ 1084 Square Destroyer A*,BFS
BRCOCOLI的博客
09-04 554
题目地址：http://poj.org/problem?id=1084 看到很多用Dancing Link X 算法，但没接触过，而且是为了练习A*，所以就想A* 一开始用 还有几个正方形数目代表h()估价函数，但是答案错了，因为有的火柴能破坏3个，有的2个，有的1 个....不能代表估价函数，并没有相容性 错误代码如下： #include #include #include #inclu
POJ 1084 Square Destroyer (重复覆盖，DLX)
weixin_30462049的博客
09-29 246
题目： http://poj.org/problem?id=1084 题意： 给你一个n*n(n<=5)的完全由火柴棍组成的正方形，已经去掉了一些火柴棍，问最少去掉多少根火柴棍使得所有1*1、2*2......n*n的正方形均被破坏掉？ 方法： 转换为重复覆盖问题，用DLX直接解决 1、精确覆盖与重复覆盖：《DLX在搜索中的应用》 http://bbs.whu.ed...
poj1084（求逆序数）
u013509299的专栏
09-04 1058
题意：给一个长度为n的序列，每次交换相邻的元素，求最少的交换次数。也就是求冒泡排序的交换次数。 解题思路：对于冒泡排序，每一次相邻交换，那么这个序列的逆序数减1，当这个序列有序是，逆序数就为0。我们用归并排序求逆序数，归并排序就是将 数组[l,r]分成[l,m],[m+1,r]进行排序，然后再归并，在归并时a[i] a[j]时，在[l,m]中有m-i+1个数比a[j]大。在归并用ans记录逆
[kuangbin]专题三 Dancing Links Square Destroyer POJ - 1084【重复覆盖】
inv0ker的博客
08-25 278
【题目描述】 The left figure below shows a complete 3*3 grid made with 2*(3*4) (=24) matchsticks. The lengths of all matchsticks are one. You can find many squares of different sizes in the grid. The size o...
poj1084Square Destroyer(LDX解重复覆盖)
ophunter的专栏
12-18 1911
题目请戳这里 题目大意:给一个n*n的用单位长度的木棍拼起来的网格图,给每个木棍按图示编号,编号范围1~2*n*(n+1).现在已知图中已经去掉了k个木棍,求还要至少去掉几根木棍能使网格图中不存在正方形.即破坏图中所有的正方形.n不超过5. 题目分析:n太小了啦,直接爆搜!dancing links优化之.将之转化成一个重复覆盖的模型. n*n的完全网格图中存在n*(n+1)*(2*n+1)
POJ - 1084 Square Destroyer （Dancing Links 重复覆盖）
兜率工的博客
01-13 322
题意： n*n的矩形阵(n&lt;=5)，由2*n*(n+1)根火柴构成，其中有很多边长为1，2...，n的正方形，现在可以拿走一些火柴，那么就会有一些正方形被破坏掉。问在已经拿走一些火柴的情况下，还需要拿走至少多少根就可以把所有的正方形破坏掉。 分析： 这个题以前在紫书上见过。用的A*做的。 当然也可以用dancing links做，让火柴做为行，让所有的正方形作为列，且如果i火柴能让j...
Python数据结构与算法（poj）：P01084——正方形破坏者
2301_79402523的博客
03-31 973
倘若讨论每根火柴是否已被拿走，没被拿走就拿走，同时对当前状态的正方形个数进行计数，与之前的进行比较从而达到剪枝的目的，这样做，哪怕后面使用位运算存储累计拿走火柴棒的状态，仍然会超时（也有可能超内存）。使用该算法时，我们首先定义一个估价函数，用于进行判断当前状态还需要的最少火柴棒数目（准确地说，可能会比实际达到的数目还要少，但剪枝的效率极高）。于是，我们改变思路，我们还是需要看火柴是否被拿走，但我们从正方形的角度进行考虑，这样计数时的复杂度就会由。注意到，尽管我们会将此时拿走火柴棒的次数与全局变量。
POJ 1084 搜索（IDA*）
Sky
10-13 2832
题意：给一个由(n+1)*n*2根火柴棒构成的边长为n正方形，每根火柴棒都有编号，已经删去了k根火柴棒，问至少再删多少根火柴棒可以破坏掉所有正方形。 【刘汝佳：《算法竞赛入门经典（第二版）》 P213】【小吐槽】 感觉做这道题的历程真是哔了狗了。一开始自己写了个暴搜果断就T了，主要是判断每个正方形存在与否的方法太暴力。之后在网上看到很多人都写的DLX，被如何记录正方形存在的方式恶心到的我下狠心决
【POJ】1084 Square Destroyer
weixin_34315665的博客
03-26 197
1. 题目描述由$n \times n, n \in [1, 5]$的正方形由$2 \times n \times (n+1)$根木棍组成，可能已经有些木棍被破坏，求至少还需破坏多少木根，可以使得不存在任何正方形？2. 基本思路这是一道非常有趣的题目，可以使用IDA*解也可以用DLX解。可以试试5 0这组数据比较两者的性能差异。(1) IDA*使用IDA*处理，是因为最后的解的范围一定不是很大，因...
POJ 1084 Square Destroyer
weixin_34240657的博客
08-31 168
POJ_1084     对于任意一个正方形，我们都至少要拿掉其中的一个火柴，于是如果构造一个行表示火柴、列表示正方形的矩阵，如果第i根火柴属于第j个正方形，那么g[i][j]=1，否则g[i][j]=0。这样这个问题就转化成了选取尽量少的行，使得每列至少有一个1，于是就可以用Dancing Links解决了。 #include&lt;stdio.h&gt; #include&lt;st...
POJ1084-重复覆盖,DLX
Wo xi Meiz
08-20 2065
这题可理解为用最少用多少火柴棒覆盖全部的正方形，以正方形为列，火柴棒为行，重复覆盖模型明显。 建图的时候要找出所有正方形所包含的火柴棒，我是这样找的： 先确定最左上边的正方形(边长为1~n)所包含的边，因为对于等大的两个正方形，其相同位置的火柴棒边的标号的差是一定的，所以算出一个正方形的边根据差就能得出其他的等大的正方形的边了。 /* 第一道像样一点的DLX重复覆盖，这题数据弱~ */
POJ_1084_SquareDestroyer（DancingLinksX重复覆盖）
OTTFF的博客
05-01 470
Square Destroyer Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 3642   Accepted: 1577 Description The left figure below shows a complete 3*3 grid made wit
POJ 1084(DLX重复覆盖)
q437634645的博客
07-18 511
问题描述：用棍子摆成一个n×n的正方形，问你最少取走多少根棍子可以使图中，任一正方形都是不完整的。 DLX重复覆盖，把棍子看作行，对应的矩阵看作列，那么选择棍子就是选择棍子对应的行并覆盖该行所包括的列。 代码如下： /*--------------------------------------------------------
poj 1084 Square Destroyer dlx解重复覆盖
sepNINE的专栏
05-02 1577
分析： 将问题转化为重复覆盖问题，DancingLink解决。 代码： //poj 1084 //sep9 #include using namespace std; const int maxN=10024; const int maxL=128; int L[maxN],R[maxN],U[maxN],D[maxN]; int C[maxN],H[maxN]; int S[maxN],
poj1084 Square Destroyer
qq_43665203的博客
02-17 393
这题的关键是如何存储信息 IDA*估计函数:找到一个未被删除的正方形并去掉所有边，但只记一次操作 一定小于等于实际 从当前的最小的正方形（使得搜索树小）开始枚举删去其中的边 代码（关键函数变量有注释） #include<iostream> #include<cstdio> #include<vector> #include<cstring> usi...
POJ 1084 Square Destroyer【Dancing Links重复覆盖】
~飞呀，飞~
09-04 2493
Square Destroyer Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 2695   Accepted: 1101 Description The left figure below shows a complete 3*3 grid made with
poj1084-舞蹈链
测试
02-24 507
题目链接：http://poj.org/problem?id=1084 DescriptionThe left figure below shows a complete 33 grid made with 2(3*4) (=24) matchsticks. The lengths of all matchsticks are one. You can find ...
题解 UVA1603 【Square Destroyer】
donglaishi1835的博客
08-19 236
题目链接：Link Solution 废话不说，先贴代码..... #include<cstdio> #include<cstring> int n,m,maxd,cnt,sum; int FullSize[625],Size[625]; bool sti[65],in[625][65]; inline int getc(int r,int c)// | 竖线 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值