11-29-2019学习记录

昨天看了一下广度意义上的深度遍历(dfs) 今天接着学到了广度意义上的广度优先遍历(bfs)

这种广度优先遍历在实际意义上与图中深度遍历优先是类似的

dfs隐含的利用了栈(递归),bfs则是利用了队列

 这道题便是利用bfs的一道题 每次从栈中弹出元素 都会把它上下左右四个方向检测将未访问可达的元素入栈

#include<iostream>
#include<queue>
using namespace std;
#define INF 1000000
#define Max_n 100
#define Max_m 100
typedef pair<int, int> P;
char maze[Max_n][Max_m];
int N, M;
int sx, sy;
int ex, ey;
int Dist[Max_n][Max_n];
int dx[4] = { -1,0,1,0 };
int dy[4] = { 0,1,0,-1 };
int bfs(){
    for (int i = 0; i < N; i++)
        for (int j = 0; j < M; j++)
            Dist[i][j] = INF;
    queue<P> S;
    Dist[sx][sy] = 0; //将始点距离置为0
    S.push(P(sx, sy));//将始点入栈
    while (S.size()){
        P p = S.front(); S.pop();
        if (p.first == ex && p.second == ey)break;//检测是否到达终点
        else{
            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 && maze[nx][ny] != '#' && Dist[nx][ny] == INF){
                    Dist[nx][ny] = Dist[p.first][p.second] + 1;
                    S.push(P(nx, ny));
                }
            }
        }
    }
    return Dist[ex][ey];
}
void solve(){
    int min = bfs();
    cout << min;
}
//读入数据
int main()
{
    cin >> N >> M;
    for (int i = 0; i < N; i++)
        for (int j = 0; j < M; j++)
            cin >> maze[i][j];
    cin >> sx >> sy >> ex >> ey;
    solve();
    return 0;
}

/*
10 10
#S######.#
......#..#
.#.##.##.#
.#........
##.##.####
....#....#
.#######.#
....#.....
.####.###.
....#...G#
0 1
9 8
*/

dfs和bfs都是属于枚举的方法

接着书上提到了贪心

贪心是遵循某种规则 不断贪心地选取当前最优策略地想法

书上给了几道很好地例题来体现 硬币问题 区间问题 字典序最小问题

再接着讲到了动态规划(dynamic programming)

提到了背包问题 利用记忆化搜索 将已经处理过的情况记录