[C++] 백준 2468 안전 영역

 
#include <iostream>
#include <algorithm>
#include <memory>
#include <queue>
#include <tuple>
 
int graph[101][101] = {};
bool visit[101][101] = {};
int DirX[4] = { 1, -1, 0, 0};
int DirY[4] = { 0, 0, 1, -1};
int N = 0;
int iMax = 0;
int iCount = 0;
std::queue<std::pair<int,int>> que = {};
 
void Check(int iNumber)
{
    iCount = 0;
 
    for (int i = 0; i < N; ++i)
    {
        for (int j = 0; j < N; ++j)
        {
            if (graph[i][j] > iNumber && !visit[i][j])
            {
                ++iCount;
 
                que.push({ i,j });
 
                while (!que.empty())
                {
                    std::pair<int, int> pair = que.front();
                    int iX = pair.first;
                    int iY = pair.second;
                    que.pop();
 
                    if (iX >= 0 && iX < N &&
                        iY >= 0 && iY < N)
                    {
                        if (!visit[iX][iY])
                            visit[iX][iY] = true;
                        else
                            continue;
                    }
 
                    else
                        continue;
 
                    for (int z = 0; z < 4; ++z)
                    {
                        int iNextX = iX + DirX[z];
                        int iNextY = iY + DirY[z];
 
                        if (iNextX >= 0 && iNextX < N &&
                            iNextY >= 0 && iNextY < N)
                        {
                            if (!visit[iNextX][iNextY] &&
                                graph[iNextX][iNextY] > iNumber)
                                que.push({ iNextX, iNextY });
 
                            else
                                continue;
                        }
                    }
                }
            }
        }
    }
 
    iMax = std::max(iMax, iCount);
}
 
int main()
{
 
    std::cin >> N;
 
    for (int i = 0; i < N; ++i)
    {
        for (int j = 0; j < N; ++j)
        {
            std::cin >> graph[i][j];
        }
    }
 
    for (int i = 0; i <= 100; ++i)
    {
        Check(i);
        memset(visit, false, sizeof(visit));
    }
 
    std::cout << iMax;
 
    return 0;
}
 

BFS로 처리