22-froglike6

[froglike6]

🔗 문제 링크

밤(Time For The Moon Night)

✔️ 소요된 시간

20분

✨ 수도 코드

수도 코드

입력 N, M, K
N×M 크기의 grid를 0으로 초기화한다
K번 반복하면서:
 x, y를 입력받아 grid\[x-1]\[y-1]를 1로 만든다 (별이 있는 칸 표시)

네 꼭짓점 (a1,b1), (a2,b2), (a3,b3), (a4,b4)를 입력받는다
모든 좌표에서 1을 빼서 0-기반 인덱스로 바꾼다

visited 배열을 N×M 크기의 False로 초기화한다
상하좌우 방향 배열 dirs를 준비한다
answer를 0으로 초기화한다

모든 칸 (i, j)에 대해 반복한다:
 만약 grid\[i]\[j]가 0이고 visited\[i]\[j]가 False라면:
  stack에 (i, j)를 넣고 visited\[i]\[j]를 True로 만든다
  countA와 countB를 0으로 초기화한다

  stack이 빌 때까지 반복한다:
   (x, y)를 stack에서 꺼낸다
   만약 (x, y)가 첫 번째 직사각형 내부라면 countA를 1 증가시킨다
   만약 (x, y)가 두 번째 직사각형 내부라면 countB를 1 증가시킨다

   dirs의 네 방향 (dx, dy)에 대해:
    nx = x + dx, ny = y + dy
    만약 nx, ny가 격자 범위 안이고 grid\[nx]\[ny]가 0이며 아직 방문하지 않았다면:
     visited\[nx]\[ny]를 True로 만들고 (nx, ny)를 stack에 넣는다

  탐색이 끝나면 answer에 countA × countB를 더한다

answer를 출력한다

떨려오는 별빛 반짝이는데 넌 어디를 보고 있는지 금방이라도 사라질 것 같은데

이 문제는 $N \times M$ 격자 위에 놓인 $K$개의 별을 피해, 두 개의 직사각형 구역을 연결할 수 있는 시작점 쌍의 개수를 구하는 문제입니다.
각각의 직사각형 $A$와 $B$에서 별이 없는 한 칸씩을 출발점으로 정해, 서로 상하좌우로만 이동해 만날 수 있는지를 판단해야 합니다.

모든 $A$ 구역의 칸과 모든 $B$ 구역의 칸을 일일이 DFS로 탐색하면 시간복잡도가 너무 커져서 시간초과가 날 수 있습니다.
그래서 저는 별에 의해 나뉘어진 빈 칸 덩어리 단위로 접근했습니다.

먼저 연결된 덩어리별로 한 번의 DFS를 돌렸습니다. 격자를 순회하며 아직 방문하지 않은 빈 칸을 찾으면, 그 칸에서 DFS를 돌려 하나의 덩어리를 모두 탐색합니다.

그런 다음, 그 덩어리 안에서 $A$ 구역에 속한 칸의 개수를 countA에, $B$ 구역에 속한 칸의 개수를 countB에 넣은 후, 이 둘을 곱해 정답에 더해주는 형식으로 이 문제를 해결했습니다.

이렇게 글로 본다면 어려울 수 있는데, 단순한 DFS 문제(장애물이 있는 격자)라고 생각하면 쉽습니다 ㅎㅎ.. 덩어리로 접근하는 방식을 떠올리는데 대부분의 시간을 쓴 것 같습니다.

📚 새롭게 알게된 내용

[dohyeondol1]

전에 머리를 싸매다가 도현님의 풀이를 보고 코드를 짰습니다.
일반적인 길찾기였다면 풀 수 있었을 것 같았는데... 조합의 수를 구하라고 해서 못풀었습니다.. ㅠㅠ

도현님의 풀이를 보고 풀어서 코드상에서 리뷰할건 따로 없는 것 같네요..

#include <iostream>
#include <vector>
#include <stack>
#include <algorithm>
using namespace std;

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    
    int N, M, K;
    cin >> N >> M >> K;
    vector<vector<int>> grid(N, vector<int>(M, 0));
    for(int i = 0; i < K; i++) {
        int x, y;
        cin >> x >> y;
        grid[x-1][y-1] = 1;
    }
    
    int a1, b1, a2, b2, a3, b3, a4, b4;
    cin >> a1 >> b1 >> a2 >> b2 >> a3 >> b3 >> a4 >> b4;
    a1--; b1--; a2--; b2--; a3--; b3--; a4--; b4--;
    
    vector<vector<bool>> visited(N, vector<bool>(M, false));
    int dir[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
    long long answer = 0;
    
    for(int i = 0; i < N; i++) {
        for(int j = 0; j < M; j++) {
            if(grid[i][j] == 0 && !visited[i][j]) {
                stack<pair<int, int>> st;
                st.push({i, j});
                visited[i][j] = true;
                long long countA = 0, countB = 0;
                
                while(!st.empty()) {
                    auto [x, y] = st.top();
                    st.pop();
                    
                    if(x >= a1 && x <= a2 && y >= b1 && y <= b2)
                        countA++;
                    if(x >= a3 && x <= a4 && y >= b3 && y <= b4)
                        countB++;
                    
                    for(int d = 0; d < 4; d++) {
                        int nx = x + dir[d][0];
                        int ny = y + dir[d][1];
                        
                        if(nx >= 0 && nx < N && ny >= 0 && ny < M && grid[nx][ny] == 0 && !visited[nx][ny]) {
                            visited[nx][ny] = true;
                            st.push({nx, ny});
                        }
                    }
                }
                
                answer += countA * countB;
            }
        }
    }
    
    cout << answer << '\n';
    return 0;
}

리뷰를 일주일전에 달려고 했는데...
죄송합니다.. ㅜ

[Fnhid]

밀린pr을 드디어 쓰게 되었네요!

저도 비슷하게 도현님의 수도코드를 참고했습니다.

저런 발상을 저절로 떠올릴 수 있도록 발전해야겠습니다..

#include <iostream>
#include <vector>
#include <stack>

#define X first
#define Y second

using namespace std;
using Pos = vector<pair<int, int>>;

template <typename T>
using Grid = vector<vector<T>>;

int dx[4] = {0, -1, 0, 1};
int dy[4] = {1, 0, -1, 0};

long long dfs(const Pos& starPos, const Pos& boxPos, int n, int m){

    long long ans = 0;

    Grid<int> grid(n, vector(m, 0));
    Grid<bool> visited(n, vector(m, false));

    for (auto pos : starPos)
        if (pos.X >= 0 && pos.X < n && pos.Y >= 0 && pos.Y < m)
            grid[pos.X][pos.Y] = 1;



    for (int i=0;i<n;i++)
    {
        for (int j=0;j<m;j++)
        {
            if (visited[i][j] == true || grid[i][j] == 1) continue;
            long long countA=0, countB=0;
            stack<pair<int, int>> st;
            st.push({i, j});
            visited[i][j] = true;
            while (!st.empty())
            {
                auto [x, y] = st.top();
                st.pop();
                if(x >= boxPos[0].X && x <= boxPos[1].X && y >= boxPos[0].Y && y <= boxPos[1].Y)
                    countA++;
                if(x >= boxPos[2].X && x <= boxPos[3].X && y >= boxPos[2].Y && y <= boxPos[3].Y)
                    countB++;

                for (int d=0;d<4;d++)
                {
                    int nx = x + dx[d];
                    int ny = y + dy[d];

                    if (nx >= 0 && nx < n && ny >= 0 && ny < m && grid[nx][ny] == false && visited[nx][ny] == false){
                        visited[nx][ny] = true;
                        st.push({nx, ny});
                    }
                }

            }
            ans += countA * countB;
        }
    }



    return ans;

}

int main()
{
    cin.tie(nullptr)->sync_with_stdio(false);

    int n, m, k;

    cin >> n >> m >> k;

    Pos starPos(k);
    Pos boxPos(4);


    for (int i=0;i<k;i++){
        cin >> starPos[i].X >> starPos[i].Y;
        starPos[i].X--;
        starPos[i].Y--;
    }

    for (int i=0;i<4;i++){
        cin >> boxPos[i].X >> boxPos[i].Y;
        boxPos[i].X--;
        boxPos[i].Y--;
    }

    cout << dfs(starPos, boxPos, n, m);

    return 0;
}