集美大学2024年团体程序设计天梯赛模拟赛( H 创造花田的魔法) 思路清晰简单明了，有代码有思路

链接：登录—专业IT笔试面试备考平台_牛客网
来源：牛客网
题目

代码呈现（后面有思路）

#include <iostream>
using namespace std;
const int N = 10e3 + 1;
//开两个数组，是因为，每一次种花以后，不能改变地形，所以，一个存答案（种花的） 一个是初始地图
char map[N][N];
char mapp[N][N];
int n, m;
int dx[8] = {-1, -1, -1, 0, 0, 1, 1, 1}, dy[8] = {-1, 0, 1, 1, -1, -1, 0, 1};

int L = 0, M = 0, G = 0, H = 0;

void dfs(int x, int y,int flog){
    //边界退出，和只向外扩一次，当flog = 2的时候就停止；
    if (x < 0 || x >= n || y < 0 || y >= m || flog == 2)
        return ;
    //flog = 1的时候说明当前的结点是 我们所需要查找结点周围8个结点之一，然后统计这里的地形
    if(flog == 1){
        if (map[x][y] == 'L') L ++;
        if (map[x][y] == 'M') M ++;
        if (map[x][y] == 'G') G ++;
        if (map[x][y] == 'H') H ++;
    }
   
    //向外扩8个方向
    for (int i = 0; i < 8; i ++){
        dfs(x + dx[i], y + dy[i], flog + 1);
    }
}

int main(){
    
    cin >> n >> m;
    //存地图
    for (int i = 0; i < n; i ++){
        for (int j = 0; j < m; j ++){
            cin >> map[i][j];
            mapp[i][j] = map[i][j];
        }
    }
    
    for (int i = 0; i < n; i ++){
        for (int j = 0; j < m; j ++){
            if(map[i][j] == 'M')//山脉不管
                continue;
            if(map[i][j] == 'H')//房屋不管
                continue;
            dfs(i,j,0);
           // cout << L << " "<< M << " " << G << " " << H <<endl;
            if (map[i][j] == 'L'){//湖泊，当且仅当周围都是湖泊的时候，种荷花 即 L = 8 ，其他都为零
                if (M == 0 && H == 0 && G == 0 && L == 8)
                    mapp[i][j] = 'S';
                L = 0, M = 0, H = 0, G = 0;//初始化
                continue;
            }
            
            if(map[i][j] == 'G'){//青草块
                if (L != 0 && H == 0)//周围8个点都没房屋 有湖泊的时候 种N 
                    mapp[i][j] = 'N';
                else if (H == 0)//没有房屋和湖泊这种B
                    mapp[i][j] = 'B';
            }
            L = 0, M = 0, H = 0, G = 0;//初始化
        }
    }
    //输出
    for (int i = 0; i < n; i ++){
        for (int j = 0; j < m; j ++){
            cout << mapp[i][j];
        }
        cout << endl;
    }
}
// 64 位输出请用 printf("%lld")

思路

第一点

题目分析完后我们得到：

地图是n * m 的

有湖泊L（当且只有它的周围8个方向都是湖泊L的时候种荷花S）

山脉M  （不种任何东西）

青草块G  1.周围没有房屋H，有湖泊L，种水仙N

                2.周围没有房屋H，没有湖泊L，种苍月草N

房屋H （不种任何东西，且周围不能种花）

第二点

那么我们可以定义四个变量 L，M，G，H 来统计当前这个点周围有哪些

这个点自己是湖泊，且周围湖泊L== 8 的话，种荷花S

这个点是青草块 1、周围房屋H == 0 且有湖泊L！= 0 种水仙 N

                            2、周围房屋H== 0 ，没有湖泊 L==0 种沧月草 B

全部用dfs（）搜索周围的地形，并且在里面统计好 LM H G

for (int i = 0; i < n; i ++){
        for (int j = 0; j < m; j ++){
            if(map[i][j] == 'M')//山脉不管
                continue;
            if(map[i][j] == 'H')//房屋不管
                continue;
            dfs(i,j,0);
           // cout << L << " "<< M << " " << G << " " << H <<endl;
            if (map[i][j] == 'L'){//湖泊，当且仅当周围都是湖泊的时候，种水仙 即 L = 8 ，其他都为零
                if (M == 0 && H == 0 && G == 0 && L == 8)
                    mapp[i][j] = 'S';
                L = 0, M = 0, H = 0, G = 0;//初始化
                continue;
            }
            
            if(map[i][j] == 'G'){//青草块
                if (L != 0 && H == 0)//周围8个点都没房屋 有湖泊的时候 种N 
                    mapp[i][j] = 'N';
                else if (H == 0)//没有房屋和湖泊这种B
                    mapp[i][j] = 'B';
            }
            L = 0, M = 0, H = 0, G = 0;//初始化
        }
    }

第三点

实现dfs（）周围搜索

首先8个方向 定义一个dx dy数组  用一个循环就可以表示8个方向

int dx[8] = {-1, -1, -1, 0, 0, 1, 1, 1}, dy[8] = {-1, 0, 1, 1, -1, -1, 0, 1};
//向外扩8个方向
    for (int i = 0; i < 8; i ++){
        dfs(x + dx[i], y + dy[i], flog + 1);
    }

重要的是只向外扩一次 所以需要用一个flog 来标记

我们把flog = 0时 这个嗲=点 向往外扩作为初始点 

然后flog = 1作为表示这个点是扩一次的点 即周围的点 并且去统计这个点的地形

然后flog = 2 的时候 就该退出了

void dfs(int x, int y,int flog){
    //边界退出，和只向外扩一次，当flog = 2的时候就停止；
    if (x < 0 || x >= n || y < 0 || y >= m || flog == 2)
        return ;
    //flog = 1的时候说明当前的结点是 我们所需要查找结点周围8个结点之一，然后统计这里的地形
    if(flog == 1){
        if (map[x][y] == 'L') L ++;
        if (map[x][y] == 'M') M ++;
        if (map[x][y] == 'G') G ++;
        if (map[x][y] == 'H') H ++;
    }
   
    //向外扩8个方向
    for (int i = 0; i < 8; i ++){
        dfs(x + dx[i], y + dy[i], flog + 1);
    }
}