ACM之近期学习总结

最近只看了一些关于dfs和bfs的基础入门的题目，像优先队列和bfs结合，dfs+剪枝，bfs+剪枝类型的题，还没有开始看。决定从明天开始再看那些综合方面的。接下来总结一下近几天以来做的关于dfs和bfs基本题的类型和通法。

一.dfs

1.dfs就是以一种单一方式走到黑，然后通过回溯等得到答案的过程。

一般用于求所有方案问题

 

2.

例题：给出一个roe*col的大写字母矩阵，一开始的位置为左上角，你可以向上下左右四个方向移动，并且不能移向曾经经过的字母。问最多可以经过几个字母。

主要实现代码：

#include<iostream>
using namespace std;
const int Max = 30;
int row, col, ans = 0;
char map[Max][Max];
bool vis[Max];
int dr[4] = {-1, 0, 0, 1};
int dc[4] = {0, -1, 1, 0};
bool inmap(int r, int c){
    if(r >= 1 && r <= row && c >= 1 && c <= col)
        return true;
    return false;
}
void dfs(int dep, int now_r, int now_c){
    if(dep > ans) ans = dep;
    for(int i = 0; i < 4; i ++){
        int r = now_r + dr[i];
        int c = now_c + dc[i];
        if(inmap(r, c) && !vis[map[r][c] - 'A']){
            vis[map[r][c] - 'A'] = true;
            dfs(dep + 1, r, c);
            vis[map[r][c] - 'A'] = false;
        }
    }
}
 
int main(){
    cin >> row >> col;
    for(int i = 1; i <= row; i ++)
        for(int j = 1; j <= col; j ++)
            cin >> map[i][j];
    memset(vis, false, sizeof(vis));
    vis[map[1][1] - 'A'] = true;
    dfs(1, 1, 1);
    cout << ans << endl;
    return 0;
}

 总结：dfs思路：

一般dfs用来求所有情况，并且要求记录路径问题，所以需要写一个void print()函数用来输出路径。在dfs搜索函数中，按照题目规则从第一个节点生成下一个节点，如果生成的下一个节点符合条件，则将它收入路径，并将此个节点标记为已访问过，然后再dfs搜索下一个节点，最后不要忘记将上一个节点还原(即回溯)。

 

dfs模板：

DFS（dep,.......）{

    if(找到解 || 走不下去)  {  

        .........

        return ;

     }

    枚举下一种情况，DFS（dep+1,........）

   将上一个节点还原（回溯）

}

 

 

二.bfs

1.bfss是先看有多少种方式可以走，然后先记录每一种方式，再按这种方式一层一层遍历，直到得到最后结果。

bfs一般用于求最短路径

 

2.例题：

给定任意的两个坐标n，k，农夫现在在坐标n处，农夫可以选择走到坐标n+1，n-1 或者2*n处，问至少经过多少步可以从n走到k处。

主要实现代码：

#include <stdio.h>
#include <string.h>
#include <queue>
using namespace std;
const int N = 1000000;
int map[N+10];
int n,k;
struct node
{
    int x,step;
};
 
int check(int x)
{
    if(x<0 || x>=N || map[x])
        return 0;
    return 1;
}
 
int bfs(int x)
{
    int i;
    queue<node> Q;
    node a,next;
    a.x = x;
    a.step = 0;
    map[x] = 1;
    Q.push(a);
    while(!Q.empty())
    {
        a = Q.front();
        Q.pop();
        if(a.x == k)
            return a.step;
        next = a;
        //每次都将三种状况加入队列之中
        next.x = a.x+1;
        if(check(next.x))
        {
            next.step = a.step+1;
            map[next.x] = 1;
            Q.push(next);
        }
        next.x = a.x-1;
        if(check(next.x))
        {
            next.step = a.step+1;
            map[next.x] = 1;
            Q.push(next);
        }
        next.x = a.x*2;
        if(check(next.x))
        {
            next.step = a.step+1;
            map[next.x] = 1;
            Q.push(next);
        }
    }
    return -1;
}
 
int main()
{
    int ans;
    while(~scanf("%d%d",&n,&k))
    {
        memset(map,0,sizeof(map));
        ans = bfs(n);
        printf("%d\n",ans);
    }
    return 0;
}

总结：bfs思路：

1.从初始状态S开始，利用规则，生成下一层的状态。

2.顺序检查下一层的所有状态，看是否出现目标状态G。

否则就对该层所有状态节点，分别利用规则。生成再下一层的所有状态节点。

3.继续按照上面思想生成下一层的所有状态节点，这样一层一层往下展开。

直到出现目标状态为止

bfs一般用队列实现

 

bfs模板：

初始化队列Q

Q={起点s}；

标记s为已访问；

while（Q非空）

{

   取Q队首元素u；

   u出队；

if（u==目标状态）

{.............}

所有与u相邻且未被访问的点进入队列；

标记u为已访问；

}