寒假所学算法复习3月12

3月12复习了深度优先搜索(dfs)和广度优先搜索(bfs)

刷了洛谷上的一道题:[POI2007]GRZ-Ridges and Valleys - 洛谷

原本想用dfs写,但写到一半,发现思路不对,于是又用bfs去写,思路如下:

地图上有三种区域,山峰,山谷,山坡,当一个相同数的区域的周围全是比这个数要小的数这个区域就是山峰,否则就是山谷,但只要有周围的一个数不是比他小或是比他大,则这个区域是山坡,于是只要一个区域一个区域的搜索,就可以统计出整个地图的各种地形的数量,关键在于对每个区域的搜索,我用的是bfs去搜,由于地图较小,数据结构用的是邻接矩阵来存图,用两个变量标记这个区域边缘的数相对于该区域的数的大小,搜完之后通过这两个标记就可以判断这个区域的地形类型,最后统计输出即可,代码如下:

1.  
   #include<bits/stdc .h>
2.  
   #define size 1002
3.  
   int maps[size][size];
4.  
   bool vismap[size][size] = {0};
5.  
   int all1 = 0, all2 = 0, n;
6.  
   int directx[8] = {0, 1, 1, 1, 0, -1, -1, -1}, directy[8] = {1, 1, 0, -1, -1, -1, 0, 1};
7.  
   struct fkl {
8.  
   int first;
9.  
   int x, y;
10.  
    } stack[1000007];
11.  
    int main() {
12.  
    int n;
13.  
    scanf("%d", &n);
14.  
    for (int i = 1; i <= n; i ) {
15.  
    for (int p = 1; p <= n; p ) {
16.  
    scanf("%d", &maps[i][p]);
17.  
    }
18.  
    }
19.  
    for (int i = 1; i <= n; i ) {
20.  
    for (int p = 1; p <= n; p ) {
21.  
    if (vismap[i][p] == true) {
22.  
    continue;
23.  
    }
24.  
    int morebig = 0, moresmall = 0;
25.  
    int head = 0, tail = 0;
26.  
    stack[tail].first = maps[i][p];
27.  
    stack[tail].x = i;
28.  
    stack[tail].y = p;
29.  
    tail ;
30.  
    while (head < tail) {
31.  
    int tx = stack[head].x, ty = stack[head].y, tf = stack[head].first;
32.  
    head ;
33.  
    for (int pi = 0; pi < 8; pi ) {
34.  
    int nx = tx directx[pi], ny = ty directy[pi];
35.  
    if ( nx <= 0 || nx > n || ny <= 0 || ny > n) {
36.  
    continue;
37.  
    }
38.  
    if (maps[nx][ny] != tf) {
39.  
    if (maps[nx][ny] < tf) {//峰
40.  
    moresmall ;
41.  
    } else {
42.  
    morebig ;
43.  
    }
44.  
    continue;
45.  
    }
46.  
    if (vismap[nx][ny] == true) {
47.  
    continue;
48.  
    }
49.  
    vismap[nx][ny] = true;
50.  
    stack[tail].first = tf;
51.  
    stack[tail].x = nx;
52.  
    stack[tail].y = ny;
53.  
    tail ;
54.  
    }
55.  
    }
56.  
    if (moresmall == 0) { //山谷
57.  
    all2 ;
58.  
    }
59.  
    if (morebig == 0) {
60.  
    all1 ;
61.  
    }
62.  
    }
63.  
    }
64.  
    printf("%d %d", all1, all2);
65.  
    }

 既然用bfs的思路出来了,那么dfs的思路不就也出来了吗,于是顺便又用dfs写了一次

1.  
   #include<bits/stdc .h>
2.  
   #define size 1002
3.  
   int maps[size][size];
4.  
   bool vismap[size][size] = {0};
5.  
   int all1 = 0, all2 = 0, n;
6.  
   int morebig = 0, moresmall = 0;
7.  
   int directx[8] = {0, 1, 1, 1, 0, -1, -1, -1}, directy[8] = {1, 1, 0, -1, -1, -1, 0, 1};
8.  
   void dfs(int x, int y, int first) {
9.  
   for (int i = 0; i < 8; i ) {
10.  
    int nx = x directx[i], ny = y directy[i];
11.  
    if ( nx <= 0 || nx > n || ny <= 0 || ny > n) {
12.  
    continue;
13.  
    }
14.  
    if (maps[nx][ny] != first) {
15.  
    if (maps[nx][ny] < first) {//峰
16.  
    moresmall ;
17.  
    } else {
18.  
    morebig ;
19.  
    }
20.  
    continue;
21.  
    }
22.  
    if (vismap[nx][ny] == true) {
23.  
    continue;
24.  
    }
25.  
    vismap[nx][ny] = true;
26.  
    dfs(nx, ny, first);
27.  
    }
28.  
    }
29.  
    int main() {
30.  
    scanf("%d", &n);
31.  
    for (int i = 1; i <= n; i ) {
32.  
    for (int p = 1; p <= n; p ) {
33.  
    scanf("%d", &maps[i][p]);
34.  
    }
35.  
    }
36.  
    for (int i = 1; i <= n; i ) {
37.  
    for (int p = 1; p <= n; p ) {
38.  
    if (vismap[i][p] == true) {
39.  
    continue;
40.  
    }
41.  
    morebig = 0, moresmall = 0;
42.  
    vismap[i][p] = true;
43.  
    dfs(i, p, maps[i][p]);
44.  
    //printf("\n%d %d\n\n", morebig, moresmall);
45.  
    if (moresmall == 0) { //山谷
46.  
    all2 ;
47.  
    }
48.  
    if (morebig == 0) {
49.  
    all1 ;
50.  
    }
51.  
    }
52.  
    }
53.  
    printf("%d %d", all1, all2);
54.  
    }

写得比较顺手,再去写一个比较难一点的:刺杀大使 - 洛谷

我最开始的思路:

题目要求:从第一行走到最后一行,每条路线上的最大伤害为这条路的伤害,求所有路线中伤害最小的路线的伤害值,用bfs,用两个标记,一个llmin,一个tllmax,分别用来存储所有路线中伤害最小的路线的伤害值,和某条路线中的个点的伤害的最大值,用bfs边搜索下一个点,边将这个点的伤害值与当前的tllmax比较,取最大的伤害值,当一个路线出来后将这个路线的伤害值与当前的llmin进行比较,取最小的,所有路线搜索完之后llmin及时最终的结果,但我提交上去后发现不仅超时,还有部分测试点错误,先贴上我的错误代码

1.  
   /*
2.  
   5 4
3.  
   0 0 0 0
4.  
   2 5 6 1
5.  
   3 1 6 7
6.  
   9 6 4 8
7.  
   0 0 0 0
8.  
   */
9.  
    
10.  
     
11.  
     
12.  
    //bfs错误思路
13.  
    #include<bits/stdc .h>
14.  
    #define size 1000
15.  
    int main() {
16.  
     
17.  
    int n, m;
18.  
    int maps[size][size];
19.  
    bool vismap[size][size] = {0};
20.  
    struct direst {
21.  
    int x, y;
22.  
    int onmax;
23.  
    } stack[size * size];
24.  
    scanf("%d %d", &n, &m);
25.  
    for (int i = 1; i <= n; i ) {
26.  
    for (int ip = 1; ip <= m; ip ) {
27.  
    scanf("%d", &maps[i][ip]);
28.  
    }
29.  
    }
30.  
    int llmin = 888888;
31.  
    int diretxy[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
32.  
     
33.  
     
34.  
    for (int i = 1; i <= m; i ) {
35.  
    int head = 0, tail = 0, tllmax = 888888;
36.  
    memset(vismap, false, sizeof(vismap));
37.  
    stack[tail].x = 2, stack[tail].y = i, stack[tail].onmax = maps[2][i];
38.  
    tail ;
39.  
    while (head < tail) {
40.  
    int tx = stack[head].x, ty = stack[head].y, tmax = stack[head].onmax;
41.  
    head ;
42.  
    for (int p = 0; p < 4; p ) {
43.  
    int nx = tx diretxy[p][0], ny = ty diretxy[p][1];
44.  
    if (nx == n - 1 && tmax > tllmax) {
45.  
    tllmax = tmax;
46.  
    continue;
47.  
    }
48.  
    if (vismap[nx][ny] == true || nx <= 2 || nx >= n - 1 || ny <= 0 || ny > m) {
49.  
    continue;
50.  
    }
51.  
    vismap[nx][ny] = true;
52.  
    stack[tail].x = nx, stack[tail].y = ny;
53.  
    if (tmax < maps[nx][ny]) {
54.  
    tmax = maps[nx][ny];
55.  
    }
56.  
    stack[tail].onmax = tmax;
57.  
    tail ;
58.  
    }
59.  
    }
60.  
    if (tllmax < llmin) {
61.  
    llmin = tllmax;
62.  
    }
63.  
    }
64.  
    printf("%d", llmin);
65.  
    }

害,看了下题解,发现思路错了,决定等以后复习完相关的知识点再来复习

//正确思路：dfs 二分查找
//或是：kruskal 点权转边权
//最大值的最小值：为啥要想到二分

搜索先就此为止吧,打算先复习其他的

这篇好文章是转载于：学新通技术网