挑战程序设计竞赛 第一章 穷竭搜索

搜索的妙用

搜索
1.深度优先搜索：
俗称dfs,就是从某个状态开始，不断转移直到无法转移，然后退回前一步的状态，继续转移其他状态，直到找到最终解；
例题：八联通
思路；

1输入 n,m;
2.遍历到一个w开始dfs，也就是说把每个w 周围能走到的点都走一遍；
dfs这个函数可以描述为从当前开始四处走，可以走到的所有路；
为了防止往回走，走过的w变为.;
4. 每一次dfs就是ans++；
5.dfs注意
边界判断：不出界加下一个点是“W”；

防止重复走走过的点 走过是’W’就改为’.’；
位置数组：利用模板，私信我，有文档word；
代码：

#include <iostream>
using namespace std;
char map[10010][10010];
bool p[10010][10010];
int n,m,ans=0;
int dir[8][2]={{1,0},{0,1},{1,1},{1,-1},{-1,1},{-1,-1},{-1,0},{0,-1}};//模板
void dfs(int x,int y)
{
	map[x][y]='.';
	int dx,dy;
	for(int i=0;i<8;++i)
	{
		int dx=x+dir[i][0];//模板
		int dy=y+dir[i][1];//模板
		if(dx>=0&&dx<=n&&dy>=0&dy<=m&&map[dx][dy]=='W') dfs(dx,dy);
	}
	return ;
}
int main()
{
	cin>>n>>m;
	for(int i=0;i<n;++i)
	{
		cin>>map[i];
	}
	for(int i = 0;i <= n;++i)
	{
		for(int j=0;j <=m ;++j)
		{
			if(map[i][j]=='W') //从每一个是W的地方开始走
			{
				dfs(i,j);
				ans++; 
			}
		}
	}
	cout<<ans;
	return 0;
}

相似的题类似这样：
细胞数量
代码：

/*
1输入一个数组；
2.如果是数字就开始判断；
3.每次把能走的就走了； 

*/
#include <iostream>
using namespace std;
int map[10010][10010];
int n,m,ans=0;
int dir[4][2]={{1,0},{0,1},{-1,0},{0,-1}};
void dfs(int x,int y)
{
	map[x][y]=0;
	for(int i=0;i<4;++i)
	{
		for(int j=0;j<4;++j)
		{
			int dx=x+dir[i][0];
			int dy=y+dir[i][1];
			if(dx>=0&&dx<=n&&dy>=0&&dy<=m&&map[dx][dy]!=0) dfs(dx,dy);
		}
	}
}
int main()
{
	cin>>n>>m;
	for(int i=1;i<=n;++i)
	{
		for(int j=1;j<=m;++j)
		{
			char c;
			cin>>c;
			map[i][j]=c-'0';
		}
			
	}
	for(int i=1;i<=n;++i)
	{
		for(int j=1;j<=m;++j)
		{
			if(map[i][j]>0&&map[i][j]<=9) 
			{
				dfs(i,j);
				ans++;
			}
		}
		
	}
	cout<<ans<<endl;
	return 0;
 } 

2.抽象dfs
例题；
输入一组数字，和最终的答案：
判断是否存在一组数据使得和为给定值；
思路：
1.dfs表示当前i的位置，每次判断取和不取，
2.结束条件：到最后一个数字的时侯，判断是否为sum；
代码：

#include <iostream>
using namespace std;
int a[10010],n,k;
bool dfs(int pos,int sum)
{
	if(pos==n) return sum==k;
	if(dfs(pos+1,sum)) return true;
	else if(dfs(pos+1,sum+a[pos])) return true;
	else return false;
 } 
int main()
{
	cin>>n>>k;
	for(int i=0;i<n;++i)
	{
		cin>>a[i];
	}
	if(dfs(0,0)) cout<<"yes";
	else cout<<"no";
	
}

总结：
每个状态可以这样表示，f(pos,sum)表示当前考虑到pos这个数，和为sum的情况：
每次有2重情况 取和不取；
取了就是（pos+1,sum+a[i]）
不取是(pos+1,a[i]);
dfs这时候描述为考虑当前pos这个位置，和为sum是否成立；
dfs（i，sum）=dfs(i+1,sum)可以描述为考虑当前加上1，不取第i加1这个数是否成立；
dfs(i,sum)=dfs(i+1,sum+a[i])可以描述为考虑当前加上1，取了这个数和为sum是否成立;
3.全排列：
不使用stl实现全排列：
思路：
抽象dfs：
想象为走路，没走过一个地方就选一个数字，
走到最后位置的时候就是结束了，可以直接输出数字排列；
这里有个回溯问题要注意：
为了防止选到一样的数字，利用一个数组记录数字是否被访问过，如果是就不选，如果不是就选，然后把这个数字设置为true;
然后利用dfs调用下一个：
如果dfs不下去了就要回溯，把这个数字改为没选过；
false;
可以理解为退回来一步，既然退回来了 有些东西也要复原；
这就是回溯；
代码：

#include <iostream>
#include <cstdio>
using namespace std;
int a[10010];
bool used[10010];
void dfs(int pos,int n)
{
	if ( pos > n)//如果每个位置都选完了就输出; 
	{
		for(int i=1;i <= n;++i)
		{
			printf("%5d",a[i]);
		}
		cout<<endl;
	}
	for(int i=1;i <= n; ++i)
	{
		if(!used[i])
		{
			a[pos]=i;
			used[i]=true;
			
			dfs(pos+1,n);
			used[i]=false;
		}
	}
	
}
int main()
{
	int n;
	cin>>n;
	dfs(1,n);//表示从第一位开始dfs；
}

总结：
dfs注意点：（这是模板可以留言向我要）
1.边界的处理：这是模板可以留言向我要
2.位置数组的利用：这是模板可以留言向我要
3.是否走过标记 注意看第一题；
抽象dfs处理：
1.把过程抽象为一个函数：
将函数描述为“做了一个什么事情”，然后不断往后转移，去想下一步要做什么事情，然后抽象出下一步做这个事情，如何用函数表达；
2.什么时候回溯；
如果是visit[i]这种标记，回溯后i点应该视为没访问过，所以需要还原，不管是全局变量还是局部；

典型：走迷宫，你走到后面走不下去了，不能继续走肯定要回溯，走过的地方改回false；

如果选数，每个数只能一次 也需要回溯，因为如果你不回溯的话这个数在后面就选不到了；
典型：全排列；