信息学奥赛一本通 1454 山峰和山谷

前言：

话说我已经好几天没更信息学奥赛一本通题解了吧，今天给大家带来BFS优化+单端队列综合的一道题目

【题目描述】

给定一个 $n×n$ 的网格状地图，每个方格 $(i,j)$有一个高度 $w_{ij}$​​ 。如果两个方格有公共顶点，则它们是相邻的。

定义山峰和山谷如下：

均由地图上的一个连通块组成；

所有方格高度都相同；

周围的方格（即不属于山峰或山谷但与山峰或山谷相邻的格子）高度均大于山谷的高度，或小于山峰的高度。

求地图内山峰和山谷的数量。特别地，如果整个地图方格的高度均相同，则整个地图既是一个山谷，也是一个山峰。

【输入】

第一行一个整数$n （2≤n≤1000）$，表示地图的大小。

接下来 $n$ 行每行 $n$ 个整数表示地图。第 $i$ 行有 $n$ 个整数 $w_{i1}, w_{i2}, \ldots, w_{in} (0 \le w_{ij} \le 1\;000\;000\;000)$，表示地图第 $i$ 行格子的高度。

【输出】

输出一行两个整数，分别表示山峰和山谷的数量。

【输入样例】

5
8 8 8 7 7
7 7 8 8 7
7 7 7 7 7
7 8 8 7 8
7 8 8 8 8

【输出样例】

2 1

【提示】

样例1解释：

样例输入2:

5
5 7 8 3 1
5 5 7 6 6
6 6 6 2 8
5 7 2 5 8
7 1 0 1 7

样例输出2:

3 3

样例2解释

代码如下

思路啊解释啊，什么的我都已经用注释的方式写在代码里了，所以，我这次就不写思路了吧！（其实就想偷懒呗，还那么多理由ㄟ( ▔, ▔ )ㄏ）

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<queue>
const int N = 1000 + 5;
const int dx[] = { 0,0,1,-1,1,1,-1,-1 };//表示这个格子往8个方向移动要加大纵坐标与横坐标
const int dy[] = { 1,-1,0,0,1,-1,1,-1 };
using namespace std;
struct Node {
    int x, y;
    int val;
    Node(){}//申明一个函数
    Node(int a, int b) : x(a), y(b) {}
    Node(int a, int b, int c) : x(a), y(b), val(c) {}
    bool operator<(const Node&rhs) 
    { 
        return val < rhs.val; 
    }
} node[N * N];//一个大小是矩阵的结构体数组
int n;
int G[N][N];
bool vis[N][N];
void downBFS(int x, int y)//用以搜索共有几个山谷，x为起始点的横坐标，y为起始点的纵坐标 
{
    queue<Node> Q;//定义一个单端队列，表示可以连结成山谷的几个点的横纵坐标
    Q.push(Node(x, y));//把起始点的横纵坐标都压入队列
    vis[x][y] = true;//用以表示这个块已被遍历
    while (!Q.empty())//如果队列不为空 
    {
        Node now = Q.front();//now为队列的首个元素
        Q.pop();//弹出首个元素
        int x = now.x, y = now.y;//x为now的横坐标，y为now的纵坐标
        for (int i = 0; i < 8; i++) //对这个点的8连通点进行遍历，看能否找到与之高度相同可以组成山谷的点
        {
            int nx = x + dx[i];//表示那个连通点的横坐标
            int ny = y + dy[i];//纵坐标
            if (nx <= 0 || ny <= 0 || nx > n || ny > n)
                continue;//超出了矩阵的范围，继续循环
            if (!vis[nx][ny] && G[x][y] <= G[nx][ny])//可以进行连通成山谷 
            {
                vis[nx][ny] = true;//表示已经遍历
                Q.push(Node(nx, ny));//将其压入队列
            }
        }
    }
}
void upBFS(int x, int y)//与搜索山谷思路一样，用以搜索山峰 
{
    queue<Node> Q;
    Q.push(Node(x, y));
    vis[x][y] = true;
    while (!Q.empty()) {
        Node now = Q.front();
        Q.pop();
        int x = now.x, y = now.y;
        for (int i = 0; i < 8; i++) {
            int nx = x + dx[i];
            int ny = y + dy[i];
            if (nx <= 0 || ny <= 0 || nx > n || ny > n)
                continue;
            if (!vis[nx][ny] && G[x][y] >= G[nx][ny]) {
                vis[nx][ny] = true;
                Q.push(Node(nx, ny));
            }
        }
    }
}
int main() {
        cin >> n;//输入这个正方形矩阵的边长
        for (int i = 1; i <= n; i++) 
        {
            for (int j = 1; j <= n; j++) 
            {
                scanf("%d", &G[i][j]);//循环输入矩阵
                int pos = (i - 1) * n + j;//对矩阵中的每一个元素进行从1到N*N的编号
                node[pos] = Node(i, j, G[i][j]);//将其输入到结构体数组中
            }
        }
        sort(node + 1, node + 1 + n * n);//以防万一，对结构体数组进行排序
        int down = 0;//表示有down个山谷
        memset(vis, false, sizeof(vis));//将vis数组全部设定为false表示尚未遍历过任意元素
        for (int i = 1; i <= n * n; i++)//从第一个元素开始 循环遍历N*N个结构体数组
        {
            int x = node[i].x;//x=这个数组的横坐标
            int y = node[i].y;//y=这个数组的纵坐标
            if (!vis[x][y])//如果这一块尚未被遍历 
            {
                downBFS(x, y);//进行广度优先搜索
                down++;//山谷数量+1
            }
        }
        int up = 0;//表示有up个山峰
        memset(vis, false, sizeof(vis));//清空整个vis数组，将他设定为false，以便下次搜索
        for (int i = n * n; i >= 1; i--) //从最后一个元素开始，循环遍历N*N个结构体数组
        {
            int x = node[i].x;//x=横坐标
            int y = node[i].y;//y=纵坐标
            if (!vis[x][y])//此块尚未被遍历 
            {
                upBFS(x, y);//进行广度优先搜索
                up++;//山峰数量+1
            }
        }
        printf("%d %d\n", up, down);//输出山峰和山谷的数量
    return 0;
}

 喜欢的小伙伴们记得多多关注博主啊，你的支持就是我的动力