第10期：搜索

夜深人静写算法（一）-搜索入门

1 DFS

1.1 求阶乘：

#include<bits/stdc++.h>
using namespace std;
int dfs(int n){
	return !n ? 1 : n * dfs(n-1);  
}
int main(){
	int n;
	cin>>n;
	cout<<dfs(n)<<endl;
	return 0;
}
/*
3
6
*/

1.2 求斐波那契数列的第n项

#include<bits/stdc++.h>
using namespace std;
int dfs(unsigned int n){
	if(n<=1){
		return 1;
	}
	return dfs(n-1)+dfs(n-2);
}
int main(){
	int n;
	cin>>n;
	cout<<dfs(n)<<endl;
	return 0;
}
/*
2
2
*/

1.3 求 n 个数的全排列

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 100;
bool visit[MAXN];
int ans[MAXN],ansSize,n;
void dfs_add(int u){
	visit[u] = true;
	ans[ansSize] = u;
	++ansSize; 
}
void dfs_dec(int u){
	--ansSize;
	visit[u] = false;
}
void dfs_print(){
	for(int i = 0; i < n; ++i){
		cout << ans[i] << " ";
	} 
	cout<<endl;
}
void dfs(int depth){
	if(depth == n){
		dfs_print();
		return;
	}
	for(int i = 1; i <= n; ++i){
		int v = i;
		if(!visit[v]){
			dfs_add(v);
			dfs(depth+1);
			dfs_dec(v);
		}
	}
}
int main(){
	cin>>n;
	dfs(0);
	return 0;
}
/*
3
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
*/

1.4 DFS高级应用

 2 基于DFS的记忆化搜索

 3 基于DFS的剪枝

剪枝满足的原则：

a. 正确性

• 剪掉的子树中如果存在可行解（或最优解），那么在其它的子树中很可能搜不到解导致搜索失败，所以剪枝的前提必须是要正确；

b. 准确性

• 剪枝要“准”。所谓“准”，就是要在保证在正确的前提下，尽可能多得剪枝。

c. 高效性

• 剪枝一般是通过一个函数来判断当前搜索空间是否是一个合法空间，在每个结点都会调用到这个函数，所以这个函数的效率很重要。

• 剪枝大致可以分成两类：可行性剪枝、最优性剪枝（上下界剪枝）。

 1）可行性剪枝

        可行性剪枝一般是处理可行解的问题，如一个迷宫，问能否从起点到达目标点之类的。

2）最优性剪枝（上下界剪枝）

        最优性剪枝一般是处理最优解的问题。以求两个状态之间的最小步数为例，搜索最小步数的过程：一般情况下，需要保存一个“当前最小步数”，这个最小步数就是当前解的一个下界d。在遍历到搜索树的叶子结点时，得到了一个新解，与保存的下界作比较，如果新解的步数更小，则令它成为新的下界。搜索结束后，所保存的解就是最小步数。而当我们已经搜索了k歩，如果能够通过某种方式估算出当前状态到目标状态的理论最少步数 s 时，就可以计算出起点到目标点的理论最小步数，即估价函数 h = k + s，那么当前情况下存在最优解的必要条件是h < d，否则就可以剪枝了。最优性剪枝是不断优化解空间的过程。

4 基于DFS的A*（迭代加深，IDA*）

迭代加深算法原理如下：
1、枚举深度。
2、根据限定的深度进行 dfs，并且利用估价函数进行剪枝。

void IDA_Star(int startState) {
    int maxDepth = 0;
    while (true) {
        if(dfs(startState, 0, maxDepth)) {
            return ;
        }
        maxDepth = maxDepth + 1;
    }
}

5 BFS

C++算法——BFS（图解）

BFS(广度优先搜索算法)

bfs详解

BFS(广度优先搜索)

BFS的理解和应用

一文弄懂搜索算法中的DFS和BFS

【例题8】给定一个无向连通图，如果两个结点间有直接的边那么权值就是1，求从1号结点出发，到所有点的最短距离。

图四-1

”

• 如图四-1所示，对以下图进行广度优先搜索；

• 1）起点为1，将它放入队列后。那么第一次从队列中弹出的一定是1，将和1相邻未被访问的结点继续按顺序放入队列中，分别是2、3、4、5、7，并且记录下它们距离起点的距离dis[x] = dis[1] + 1 (x 属于集合 {2, 3, 4, 5, 7})；

• 2）然后弹出的元素是2，和2相邻未被访问的结点是10，将它也放入队列中，记录dis[10] = dis[2] + 1；

• 3）接着弹出5，放入6（4由于已经被访问过，所以不需要再放入队列中）；

• 4）弹出7，放入8、9。队列为空后结束搜索，搜索完毕后，dis 数组就记录了起点1到各个点的最短距离；

const int inf = -1;

void bfs(int u) {
    queue <int> q;
    memset(dis, inf, sizeof(dis));               // 1
    dis[u] = 0;                        
    q.push(u);
    while(!q.empty()) {
        u = q.front();                           // 2
        q.pop();
        
        for(int v = 1; v <= n; ++v) {
            if(!adj[u][v]) continue;             // 3
            if(dis[v] != inf) continue;          // 4
            
            dis[v] = dis[u] + 1;                 // 5
            q.push(v);
        }
    }
}

• 1）dis[u]数组用来标记从起点到 u 的最短距离，初始化为 -1 代表无限远；

• 2）每次从队列中弹出一个元素，这里队列采用 STL 的动态队列；

• 3）adj[u][v]=0代表不连通，则直接跳过；

• 4）dis[v] != inf代表 v 这个结点已经访问过，则直接跳过；

• 5）扩展下一个结点，并且放入队列中，等待下次弹出；

 

6 BFS应用