学习笔记第二章挑战程序设计竞赛2.1

2.1最基础的"穷竭搜索"

2.1.4深度优先搜索

深度优先搜索(DFS,Depth-First Search)是搜索的手段之一。它从某个状态开始，不断地转移状态直到无法转移，然后回退到前一步的状态，继续转移到其他状态，如此不停反复，直到找到最终的解。

例题：部分和问题

挑战程序设计竞赛page.30

思路:从a₀开始按顺序决定每个数字加还是不加，在全部n个数都决定后再判断它们的和是不是为k即可。因为状态数是2ⁿ，所以复杂度为O(2ⁿ)。

int n,a[maxn],k;
bool dfs(int dep,int sum){
	if(i==n)return sum==k;//终止条件
	if(dfs(i+1,sum))return true;//不加当前的数
	if(dfs(i+1,sum+a[i]))return true;//加上当前的数
	return false;
}
void solve(){
	if(dfs(0,0))cout << "Yes" << endl;
	else cout << "No" << endl;
}

深度优先搜索从最开始的状态出发，遍历所有可以到达的状态，由此可以对所有的状态进行操作，或者列举出所有的状态。

例题：Lake Counting (POJNo.2386)

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=1005;
char g[maxn][maxn];
int n,m;
void dfs(int x,int y){
	g[x][y]='.';
	for(int dx=-1;dx<=1;dx++){
		for(int dy=-1;dy<=1;dy++){
			int nx=x+dx;
			int ny=y+dy;
			if(0<=nx&&0<=ny&&nx<n&&ny<m&&g[nx][ny]=='W')dfs(nx,ny);
		}
	}
	return;
} 
int main(){
	scanf("%d%d",&n,&m);
	for(int i=0;i<n;i++){
		scanf("%s",g[i]);
	}
	int ans=0;
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			if(g[i][j]=='W'){
				dfs(i,j);
				ans++;
			}
		}
	}
	printf("%d\n",ans);
	return 0;
}

2.1.5宽度优先搜索

宽度优先搜索(BFS,Breadth-First Search)也是搜索的手段之一。它与深度优先搜索类似，从某个状态出发探索所有可以到达的状态。
与深度优先搜索的不同支出在于搜索的顺序，宽度优先搜索总是先搜索距离处使状态近的状态。对于同一个状态，宽度优先搜索只经过依次，因此复杂度为O(状态数 x 转移的方式)。
深度优先搜索隐式的利用了栈进行计算，而宽度优先搜索则利用了队列，搜索时首先将初始状态记录到队列里，此后从队列的前端不断取出状态，直到从该状态中把所有能到达的状态加入队列中。如此往复，直到队列被取空或找到了问题的解。

例题：迷宫的最短路径

程序挑战设计竞赛page 34

宽度优先搜索按照距开始状态由近及远的顺序进行搜索，因此可以很容易地来求最短路径，或者最少操作之类问题地答案。这个问题中状态仅仅是目前所在位置地坐标，因此可以构造程pair或者编码为int来表示状态。
宽度优先搜索中，只要将已经访问过的状态用标记管理起来，就可以很好地左到由近至远地搜索，不妨用d[N][M]数组来将最短距离保存起来，初始时用充分大的常数INF来初始化他，这样尚未到达的位置就是INF，同时起到了标记的作用。
虽然到达终点时就会停止搜索可如果继续下去直到队列为空的话，就可以计算出各个位置的最短距离。
因为要实现4个不同方向的移动，用dx[4]和dy[4]两个数组来表示四个方向向量。这样就可以实现四个方向的移动遍历。

const int INF=1e8;
typedef pair<int,int> P;
int d[maxn][maxn];
char g[maxn][maxn];
int N,M;
int sx,sy,ex,ey;//起点和终点
int dx[]={1,0,-1,0},dy[]={0,1,0,-1};
int bfs(){
	queue<P> que;
	for(int i=0;i<N;i++){
		for(int j=0;j<M;j++){
			d[i][j]=INF;
		}
	}
	que.push(P(sx,sy));
	d[sx][sy]=0;
	while(!que.empty()){
		P p=que.front();
		que.pop();
		if(p.first==ex&&p.second==ey)return d[ex][ey];
		if(d[p.first][p.second]!=INF)continue;
		for(int i=0;i<4;i++){
			int nx=p.first+dx[i];
			int ny=p.second+dy[i];
			if(nx>=0&&nx<N&&ny>=0&&ny<M&&g[nx][ny]!='#'&&d[nx][ny]!=INF){
				d[nx][ny]=d[p.first][p.second]+1;
				qie.push(P(nx,ny));
			}
		}
	}
	return INF;
}
void solve(){
	int res=bfs();
	if(res==INF)cout << "-1" << endl;
	else cout << res << endl;
}

宽度优先搜索会把状态逐个加入队列，通常需要与状态数成正比的内存空间。反之，深度优先搜索是与最大的递归深度成正比的。一般与状态数相比，递归的深度并不会太大。所以可以认为深度优先搜索更加节省内存。
此外，也有采用与宽度优先搜索类似的状态转移顺序，并且注重节约内存占用的迭代加深深度优先搜索(IDDFS)。IDDFS是一种再最开始将深度优先搜索的递归次数限制在1次，在找到解之前不断增加递归深度的方法。

2.1.6特殊状态的枚举

虽然生成可行解空间多采用深度优先搜索，但在状态空间比较特殊时其实可以很简短地实现。比如，C++的标准库中提供了next_permutation这一函数，可以把n个元素的共n!种不同的排列生成出来，又或者，通过使用位运算，可以枚举从n个元素中取出k个共C_n^k状态或是某个集合中的全部子集等。

bool used[maxn];
int perm[maxn];
//生成0到n-1的n!中排列
void permutation(int pos,int n){
	if(pos==n){
		//这里写对perm的操作
		return;
	}
	for(int i=0;i<n;i++){
		if(!used[i]){
			perm[pos]=i;
			used[i]=true;
			permutation(pos+1,n);
			used[i]=false;
		}
	}
}

#include<algorithm>
//即使有重复的元素也会生成所有的排列
//next_permutation是按照字典序来生成下一个排列的
void permutation(){
	for(int i=0;i<n;i++){
		perm2[i]=i;
	}
	do{
		//这里写对perm2的操作
		}while(next_permutation(perm2,perm2+n));
}