poj1321 dfs（bool数组memset更快（比int），15ms左右）

最新推荐文章于 2021-11-22 11:06:54 发布
最新推荐文章于 2021-11-22 11:06:54 发布
阅读量184 收藏
点赞数
分类专栏： 搜索专题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51626694/article/details/116101269
版权

八皇后问题 递归 优化 状态跟踪 回溯法
关键词由CSDN通过智能技术生成 
//Time
//32ms
//Memory
//184kB
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
char s[10][10];
int ss[10];
int n,k,num;
void dfs(int l,int step)
{
    if(step==k)
    {
        num++;
        return;
    }
    for(int i=l;i<n;i++)
        for(int j=0;j<n;j++)
    {
        if(ss[j]||s[i][j]!='#')continue;     //这里有一个妙用
        ss[j]=1;dfs(i+1,step+1);ss[j]=0;
    }

}
int main()
{
    while(scanf("%d%d",&n,&k)!=EOF)
    {
        num=0;
        if(n==-1&&k==-1)
            return 0;
        memset(s,0,sizeof s);
        memset(ss,0,sizeof ss);
        for(int i=0;i<n;i++)
            scanf("%s",&s[i]);
        dfs(0,0);
            cout<<num<<endl;
    }

}


Time
32ms
Memory
184kB
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
char s[10][10];
bool ss[10];
int n,k,num;
void dfs(int l,int step)
{
    if(step==k)
    {
        num++;
        return;
    }
    for(int i=l;i<n;i++)
        for(int j=0;j<n;j++)
    {
        if(ss[j]||s[i][j]!='#')continue;     //这里有一个妙用
        ss[j]=true;dfs(i+1,step+1);ss[j]=false;
    }

}
int main()
{
    while(scanf("%d%d",&n,&k)!=EOF)
    {
        num=0;
        if(n==-1&&k==-1)
            return 0;
        memset(s,0,sizeof s);
        memset(ss,false,sizeof ss);
        for(int i=0;i<n;i++)
            scanf("%s",&s[i]);
        dfs(0,0);
            cout<<num<<endl;
    }

}


Time
47ms
Memory
196kB
#include<iostream>
using namespace std;

bool chess[9][9];
bool vist_col[9];  //列标记
int status;  //状态计数器
int n,k;

void DFS(int row,int num)  //逐行搜索，row为当前搜索行，num为已填充的棋子数
{
	if(num==k)
	{
		status++;
		return;
	}

	if(row>n)    //配合下面DFS(row+1,num); 语句使用，避免搜索越界
		return;
    for(int i=row;i<=n;i++)
	for(int j=1;j<=n;j++)
		if(chess[i][j] && !vist_col[j])
		{
			vist_col[j]=true;  //放置棋子的列标记
			DFS(i+1,num+1);
			vist_col[j]=false; //回溯后，说明摆好棋子的状态已记录，当前的列标记还原
		}

//	DFS(row+1,num);   //这里是难点，当k<n时，row在等于n之前就可能已经把全部棋子放好
	                  //又由于当全部棋子都放好后的某个棋盘状态已经在前面循环时记录了
	                  //因此为了处理多余行，令当前位置先不放棋子，搜索在下一行放棋子的情况
	return;
}

int main(int i,int j)
{
	while(cin>>n>>k)
	{
		if(n==-1 && k==-1)
			break;

		/*Initial*/

		memset(chess,false,sizeof(chess));
		memset(vist_col,false,sizeof(vist_col));
		status=0;

		for(i=1;i<=n;i++)
			for(j=1;j<=n;j++)
			{
				char temp;
				cin>>temp;
				if(temp=='#')
					chess[i][j]=true;
			}

		DFS(1,0);  //注意初始化的值别弄错了
		cout<<status<<endl;
	}
	return 0;
}

简单模板，一行一行的搜索，和八皇后差不多但是还有一种更快的方法

//Memory Time 
//184K   32MS 
 
#include<iostream>
using namespace std;
 
bool chess[9][9];
bool vist_col[9];  //列标记
int status;  //状态计数器
int n,k;
 
void DFS(int row,int num)  //逐行搜索，row为当前搜索行，num为已填充的棋子数
{
	if(num==k)
	{
		status++;
		return;
	}
 
	if(row>n)    //配合下面DFS(row+1,num); 语句使用，避免搜索越界
		return;
 
	for(int j=1;j<=n;j++)
		if(chess[row][j] && !vist_col[j])
		{
			vist_col[j]=true;  //放置棋子的列标记
			DFS(row+1,num+1);
			vist_col[j]=false; //回溯后，说明摆好棋子的状态已记录，当前的列标记还原
		}
 
	DFS(row+1,num);   //这里是难点，当k<n时，row在等于n之前就可能已经把全部棋子放好
	                  //又由于当全部棋子都放好后的某个棋盘状态已经在前面循环时记录了
	                  //因此为了处理多余行，令当前位置先不放棋子，搜索在下一行放棋子的情况
	return;
}
 
int main(int i,int j)
{
	while(cin>>n>>k)
	{
		if(n==-1 && k==-1)
			break;
 
		/*Initial*/
 
		memset(chess,false,sizeof(chess));
		memset(vist_col,false,sizeof(vist_col));
		status=0;
 
		for(i=1;i<=n;i++)
			for(j=1;j<=n;j++)
			{
				char temp;
				cin>>temp;
				if(temp=='#')
					chess[i][j]=true;
			}
 
		DFS(1,0);  //注意初始化的值别弄错了
		cout<<status<<endl;
	}
	return 0;
}

这个代码和本人写的雷同，只是在刚开始的时候标记好了#号，

Time
125ms
Memory
184kB
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
char s[10][10];
int ss[10];
int n,k,num;
void dfs(int l,int step)
{
    if(step==k)
    {
        num++;
        return;
    }
    if(l>n)return ;
        for(int j=0;j<n;j++)
    {
        if(ss[j]||s[l][j]!='#')continue;     //这里有一个妙用
        ss[j]=1;dfs(l+1,step+1);ss[j]=0;
    }
    dfs(l+1,step);
    return ;
}
int main()
{
    while(scanf("%d%d",&n,&k)!=EOF)
    {
        num=0;
        if(n==-1&&k==-1)
            return 0;
        memset(s,0,sizeof s);
        memset(ss,0,sizeof ss);
        for(int i=0;i<n;i++)
            scanf("%s",&s[i]);
        dfs(0,0);
            cout<<num<<endl;
    }

}


Time
110ms
Memory
184kB
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
char s[10][10];
int ss[10];
int n,k,num;
void dfs(int l,int step)
{
    if(step==k)
    {
        num++;
        return;
    }
    if(l>n)return ;
        for(int j=0;j<n;j++)
    {
        if(!ss[j]&&s[l][j]=='#'){ss[j]=1;dfs(l+1,step+1);ss[j]=0;}    //这里有一个妙用
    }
    dfs(l+1,step);
    return ;
}
int main()
{
    while(scanf("%d%d",&n,&k)!=EOF)
    {
        num=0;
        if(n==-1&&k==-1)
            return 0;
        memset(s,0,sizeof s);
        memset(ss,0,sizeof ss);
        for(int i=0;i<n;i++)
            scanf("%s",&s[i]);
        dfs(0,0);
            cout<<num<<endl;
    }

}


Time
141ms
Memory
184kB
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
char s[10][10];
int ss[10];
int n,k,num;
bool g[10][10];
void dfs(int l,int step)
{
    if(step==k)
    {
        num++;
        return;
    }
    if(l>n)return ;
    for(int j=0; j<n; j++)
    {
        if(!ss[j]&&g[l][j])
        {
            ss[j]=1;
            dfs(l+1,step+1);
            ss[j]=0;
        }    //这里有一个妙用
    }
    dfs(l+1,step);
    return ;
}
int main()
{
    while(scanf("%d%d",&n,&k)!=EOF)
    {
        num=0;
        if(n==-1&&k==-1)
            return 0;
        memset(s,0,sizeof s);
        memset(g,false,sizeof g);
        for(int i=0; i<n; i++)
            for(int j=0;j<n;j++)
            {
                char ch;
                cin>>ch;
                if(ch=='#')
                    g[i][j]=true;
            }
        dfs(0,0);
        cout<<num<<endl;
    }

}

Time
110ms
Memory
184kB
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
bool ss[10];
int n,k,num;
bool g[10][10];
void dfs(int l,int step)
{
    if(step==k)
    {
        num++;
        return;
    }
    if(l>n)return ;
    for(int j=0; j<n; j++)
    {
        if(!ss[j]&&g[l][j])
        {
            ss[j]=true;
            dfs(l+1,step+1);
            ss[j]=false;
        }    //这里有一个妙用
    }
    dfs(l+1,step);
    return ;
}
int main()
{
    while(scanf("%d%d",&n,&k)!=EOF)
    {
        num=0;
        if(n==-1&&k==-1)
            return 0;
        memset(ss,0,sizeof ss);
        memset(g,false,sizeof g);
        for(int i=0; i<n; i++)
            for(int j=0;j<n;j++)
            {
                char ch;
                cin>>ch;
                if(ch=='#')
                    g[i][j]=true;
            }
        dfs(0,0);
        cout<<num<<endl;
    }

}
YikNjy
关注
专栏目录
memset, fill 对bool，int 赋值的效率
weixin_30783629的博客
07-01 488
memset对bool型变量赋false比对int型变量赋0快了10倍 fill对bool型变量赋false和对int型变量赋0效率一样 fill对int型变量赋0比memset对int型变量赋0慢了10倍 归结来说，以后要赋变量false的初值时，应该用bool型变量，用memset赋 #include <cstdio> #include <cstrin...
Poj1321 棋盘问题 DFS
Megumin的博客
07-20 324
Description 在一个给定形状的棋盘（形状可能是不规则的）上面摆放棋子，棋子没有区别。要求摆放时任意的两个棋子不能放在棋盘中的同一行或者同一列，请编程求解对于给定形状和大小的棋盘，摆放k个棋子的所有可行的摆放方案C。 Input 输入含有多组测试数据。  每组数据的第一行是两个正整数，n k，用一个空格隔开，表示了将在一个n*n的矩阵内描述棋盘，以及摆放棋子的数目。 n
memset和fill_n比较
终有绿洲摇曳在沙漠
02-24 654
memset和fill_n比較 1.memset是对每个字节赋值，而int有4字节(32位) 比如这样,memset(a,1,sizeof(a)); 则a中的每个元素都被赋值成为2进制数为，00000001000000010000000100000001，的数 转换成10进制就是16843009 所以，一般用memset对数组赋0或-1，赋其他的值就要用循环来实现.   函数名: m
memset的用法
caobnu的博客
11-27 334
memset是以字节为单位填充 今天做dijkstra卡在了memset上， bool *S = new bool[n];//最短路径顶点集 memset(S, 0, sizeof(S)); 以为这样就可以把S[i]都置为0，但只有前四个是0. 这是因为sizeof(S)是一个bool*类型的，是四个字节，所以就memset就填充了四个字节 有bool类型是一个字节，所以前四个S[
C++ bool和int类型的vector容器以及C风格数组访问速度比较
yibeiyese的博客
10-11 1639
在做一道LeetCode练习题（416.分割等和子集）时，我发现我模仿官方答案写的程序运行速度比官方答案耗时多几倍，于是就开始了一行一行的比对，最后发现原来是vector<int>和vector<bool>的区别。 对于只需要区分true或false的情况，使用bool变量是非常清晰的，而使用int变量则显得不太容易阅读（除非加注释）。而且，毕竟bool变量号称只占1个字节，而int要占8字节（64位系统）。直观上肯定觉得bool型用起来会更快。 但是，我vector<in
【常用函数1】memset()函数的使用
qq_34860220的博客
04-11 786
1、概述 memset()函数，称为按字节赋值函数，使用时需要加头文件 #include<cstring>或者#include<string.h>。通常有两个用法： （1）用来给整形数组整体赋值为0或者-1； （2）给字符数组整体赋值 2、整形数组整体赋值 整形数组整体赋值为0或-1: #include <iosream> #include &lt...
POJ1321-棋盘问题
weixin_43669652的博客
12-12 264
题目： Description 在一个给定形状的棋盘（形状可能是不规则的）上面摆放棋子，棋子没有区别。要求摆放时任意的两个棋子不能放在棋盘中的同一行或者同一列，请编程求解对于给定形状和大小的棋盘，摆放k个棋子的所有可行的摆放方案C。 Input 输入含有多组测试数据。 每组数据的第一行是两个正整数，n k，用一个空格隔开，表示了将在一个n*n的矩阵内描述棋盘，以及摆放棋子的数目。 n <= ...
poj1321.棋盘问题
Alphacoo的博客
11-19 423
传送门 题意 在一个给定形状的棋盘（形状可能是不规则的）上面摆放棋子，棋子没有区别。要求摆放时任意的两个棋子不能放在棋盘中的同一行或者同一列，请编程求解对于给定形状和大小的棋盘，摆放k个棋子的所有可行的摆放方案C。 分析 这题和N皇后有点相似,但还是有不同点: 1.N皇后还要求对角线和辅对角线都不能放,需要使用额外数组去判断对角线和辅对角线有没有放过棋子 2.N皇后初始化时每个位置只有一种状态,而这题初始化时每个位置有'#'和'.',只有'#'才可以放 搜索的结束条件为： 1.已经放好的棋子数量等于k,
牛客oj 习题9.2神奇的口袋（DFS）&& poj2362 Square（DFS）
Iguodala的博客
03-19 235
最基础的暴搜，连枝都没剪都能过，好水啊。。。 #include <cstdio> #include <iostream> #include <algorithm> #include <string> #include <cstring> #include <vector> #include <sta...
POJ1011题解(dfs+减枝)
wangjunjie_123的博客
12-22 1414
POJ1011题解(dfs+减枝，好理解一点) 题意：n根不同长度的小棍，拼成若干长棍，要这些长棍的长度相等，并且小棍刚好用完，问拼成长棍的最短长度是？ 思路：首先考虑搜索的方向，最短，那肯定是从最短的情况开始递增，最短的可能情况那肯定就是最长的的单个棍子，所以首先把这些小棍排序，从大到小，并计算这些棍子总和，拼成的长棍的长度从最长的小棍开始搜索，搜索的过程也是判断，用总和除以这个长度得到应该拼成的长棍个数，递归搜索判断小棍之间能否相组合成满足这么多个长度相等的长棍。 在搜索过程中 注意四个地方可以剪枝（效
memset的实验
weixin_30835649的博客
10-23 199
关于memset的实验 　　实验一：memset对char数组赋初值 #include<iostream> using namespace std; int main() { char a[110]; memset(a,'1',sizeof(a)); for(int i=0;i<110;i++) co...
memset函数的使用心得
brk1985的专栏
06-24 802
1、memset函数原来是用来初始化字符的； 2、
memset的实现及改进
c的专栏
11-08 1115
memset的实现及改进 memset函数，用"byte"的值填充内存 void *mymemset(void *pv, byte b, int size) { byte *pb = (byte *)pv; while(size-- > 0) *pb++ = b; return (pv); } 但是许多计算机上通过先将要填充到内存块中的小值拼成较大的数据类型，然后用拼出的大值填
关于C++ memset函数使用的问题
CESC的博客
06-17 2万+
1. 关于该函数 函数原型：  memset(void *s,int ch,size_t n)       函数说明：       memset函数是计算机中C/C++语言函数。将s所指向的某一块内存中的前n个字节的内容全部设置为ch指定的              ASCII值， 第一个值为指定的内存地址，块的大小由第三个参数指定，这个函数通常为新申请的内存做初始化工
Leetcode 036有效的数独(初始化bool数组的两种方法) C++:memset(st,0,sizeof st),JAVA:Arrays.fill(st,false)；
Myblog
11-22 593
地址 https://leetcode-cn.com/problems/valid-sudoku/submissions/ 描述 代码 y总的代码 class Solution { public: bool isValidSudoku(vector<vector<char>>& b) { bool stu[9]; //数字 1-9 在每一行只能出现一次。 for(int i=0;i<9;i++){
初涉数组(bool数组）
Jian_Ze的博客
07-18 1万+
初涉数组(bool数组） c语言中bool数组的使用方法： 1.导入 首先要导入stdbool.h头文件: #include <stdbool.h> 2.声明 int m = 5; bool flag [m]; 3.初始化 虽然bool类型默认值是0，但是仍要初始化，不初始化会出现以下结果: 即初始值不是0 用f...
C++中的bool类型
bendanfly的博客
07-12 3万+
学过C语言的程序员应该清楚，在C语言中，是没有bool这个基础类型的。在C语言中，当我们要表示真或假的时候，都是定义一个非bool类型来使用的。 在C++中，加入了布尔bool这种基础的类型，用true和false来表示真或者假，也可以用非0值来表示真，用0来表示假。在C++中，虽然布尔类型只表示true和false，看起来好像可以用一个位来存储布尔类型的变量，但其实，布尔类型在C++中是占用一个...
bool数组初始化
热门推荐
Adrianna的专栏
04-17 4万+
输入memset(boolArray,0,sizeof(Array)); 头文件是#include<memory.h>; 如果初始化为全部false，c++有一个零初始化器（zero-initializer） bool boolArray[ARRAY_SIZE] = { 0 }; 这个零初始化器是通用的，其他类型的数组也可以通过这个初始化； char myarray[ARRAY_SIZE] =
c++ memset 语言_C/C++知识点之解析memset用来初始化整个“内存块”的值
weixin_39815310的博客
12-21 301
本篇文章主要讲述C/C++知识点之解析memset用来初始化整个“内存块”的值，希望阅读本篇文章以后大家有所收获，帮助大家对相关内容的理解更加深入。1.引用C++中，memset通常包含在头中。#include#includeusingnamespacestd;intmap[10];intmain(){memset(map,0x3f3f3f3f,sizeof(map));for(i...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值