HLG1134

#include <stdio.h>
#include <string.h>
#define MAX_SIZE 1005

int map[MAX_SIZE][MAX_SIZE], visit[MAX_SIZE][MAX_SIZE];
int n, m, num, height;
int move[4][2] = {{-1, 0},  {0, -1}, {1, 0}, {0, 1}};

struct node{
       int x;
       int y;
}start;

int check(int x, int y)
{
       if(x > 0 && x <= n && y > 0 && y <= m
          && map[x][y] <= height && visit[x][y] == 0)
       {
              return 1;
       }else return 0;

}
///其他的毫无新意，只有dfs不同，他是用递归的方法，进行深度搜索
void dfs(struct node test)
{
       struct node now;
       struct node temp;
       int i;
       temp = test;
       visit[test.x][test.y] = 1;
       num++;

       for(i = 0; i < 4; ++i)
       {
              now.x = temp.x + move[i][0];
              now.y = temp.y + move[i][1];
              if(check(now. x, now.y))
              {
                     ///递归不断进行搜索，
                     dfs(now);
              }
       }
}
int main()
{
       int i, j;
       while(scanf("%d %d %d %d", &n, &m, &start.x, &start.y) != EOF
             && (n > 0) && (n <= 1000) && (m > 0) && (m <= 1000)
             && (start.x > 0) && (start.x <= 1000) && (start.y > 0) && (start.y <= 1000))
       {
              for(i = 1; i <= n; ++i)
              {
                     for(j = 1; j <= m; ++j)
                     {
                            scanf("%d", &map[i][j]);
                     }
              }
              height = map[start.x][start.y];
              memset(visit, 0, sizeof(visit));
              num = 0;
              dfs(start);
              printf("%d\n", num);
       }
    return 0;
}

以上是dfs

#include <stdio.h>
#include <string.h>
#define MAX_SIZE 1010

///依题意定下地图和其访问图的大小
int map[MAX_SIZE][MAX_SIZE], visit[MAX_SIZE][MAX_SIZE];
///num为地图上泉水可到之处,hight为泉眼的高低
int num, n, m, hight;
///初始化的四个方向
int dire[4][2] = {{-1, 0}, {0 , -1}, {1, 0}, {0 , 1}};
///结构体，一次存储坐标x， y，并定义了结构体queueu
struct node
{
    int x;
    int y;
} start, queue[MAX_SIZE * MAX_SIZE];
///test当前点是否满足走的条件，并返回相应的值
int test(int x, int y)
{
    if(x > 0 && x <= n && y > 0 && y <= m && map[x][y] <= hight
            && visit[x][y] == 0)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
///bfs对能走的路进行遍历
void bfs(struct node start)
{
    ///定义队列头和尾
    int front, tile;
    int k;
    ///定义用来进行当前值判断的now，还有进行值存放的temp
    struct node now, temp;
    ///将队头和队尾进行初始化
    front = 0;
    tile = 0;
    ///将泉眼位置进行标记，
    visit[start.x][start.y] = 1;
    ///将初始位置入队
    queue[tile++] = start;
    ///能够进水的格子加一
    num++;
///循环直front >= tile,队内元素被全部拿尽
///一开始看学长的代码，front <= tile ,结果交上去总是判错，当然front ！= tile也可
    while(front < tile)
    {
       ///每次将对头的值赋给temp
        temp = queue[front++];
        ///对当前位置的4个方向进行判断，如果其余位置未被探索将其入队，
        ///并进形颜色的标记,并将能进水的格子数加一
        for(k = 0; k < 4; ++k)
        {
            now.x = temp.x + dire[k][0];
            now.y = temp.y + dire[k][1];
            if(test(now.x, now.y))
            {
                queue[tile++] = now;
                visit[now.x][now.y] = 1;
                num++;
            }
        }
    }

}

int main()
{
    int i, j;
    while(scanf("%d %d %d %d", &n, &m, &start.x, &start.y) != EOF
          && (n > 0) && (n <= 1000) && (m > 0) && (m <= 1000)
          && (start.x > 0) && (start.x <= 1000)
          && (start.y > 0) && (start.y <= 1000))
    {
        memset(visit, 0, sizeof(visit));
        for(i = 1; i <= n; ++i)
        {
            for(j = 1; j <= m; ++j)
            {
                scanf("%d", &map[i][j]);
            }
        }
        num = 0;
        hight = map[start.x][start.y];

        bfs(start);
        printf("%d\n", num);
    }
    return 0;
}

以上为bfs