28-g0rnn

[g0rnn]

🔗 문제 링크

상어 중학교

✔️ 소요된 시간

2h 30m

✨ 수도 코드

상어 잡는데 시간을 오래 썻네요.. 메서드를 구현하는게 정말 어려웠습니다. 사소한 부분에서 캐치해야할게 많더군요.

구현은 메서드 4개만 완성하면 됩니다.

1. 블록 그룹을 생성하는 bfs
2. 블록 그룹을 삭제하는 bfs
3. 회전
4. 중력장

bfs

먼저 가장 어려운 블록 그룹을 생성하는 메서드입니다. 처음엔 블록 그룹의 size만 반환하면 될거라 생각했는데 블록 그룹의 우선순위가

블록 그룹의 크기 -> 무지개 블록 개수 -> 행 크기 -> 열 크기

이므로 생성한 블록 그룹에 대해 4가지 정보가 필요해서 배열의 형태로 반환합니다.

무지개 블록은 중복 방문이 가능하기 때문에 visited 배열을 두개 써야합니다. visited는 블록 그룹을 탐색하는데 사용되고, globalVisited는 무지개 블록을 제외한 블록 그룹 생성 현황입니다.

기준 블록을 찾기 위해 blocks를 순회하며 행 번호가 가장 작으면서 열번호가 가장 작은 녀석을 찾습니다.

board를 회전시키는 메서드는 쉬우니 넘어가고, 중력장은 순회 방향만 유의하면 될거 같습니다.

적고보니 어려운 부분은 크게 없는거 같습니다.. 근데 아마 사소한 실수를 하게 된다면 시간을 무지막지하게 써버릴 문제니 문제 잘읽고 침착하게 푸시길 바라겠습니다! 물론 전 지햄과 함께 했습니다 :) 그래도 오래 걸렷네요

📚 새롭게 알게된 내용

[9kyo-hwang]

어휴 디버깅에 시간을 엄청 썼네요 ㅋㅋ...

1. 한 사이클마다 사용되는 전역 방문 체크 배열과 특정 블록 그룹에서 사용되는 지역 방문 체크 배열을 별도로 둬야 하는 것
2. 블록 그룹의 크기 비교를 잘못한 것(...)

이 2가지 때문에 결과가 살짝 삐꾸가 나서 참 고생 많이 했습니다 허허...

블록 그룹에 대해 들고 있어야 할 정보가 많아서, 저는 구조체를 하나 정의했습니다. 기준 블록 좌표, 일반 블록 개수, 무지개 블록 개수, 그룹에 속하는 블록들을 들고 있도록 했습니다. 또한 블록 크기를 비교하는 연산자를 정의했습니다. 이 구조체 덕에 해당 블록 그룹을 지우는 작업은 쉽게 가능하죠 :)

삼성이 좋아하는 중력 작용과 회전... 이젠 그만 좋아할 때가 되지 않았나 싶네요 ㅋㅋㅋ

#include <bits/stdc++.h>
using namespace std;
using Vector2 = pair<int, int>;

constexpr int BLACK    = -1;
constexpr int RAINBOW  = 0;
constexpr int REMOVED  = -2;

constexpr int MAX_N = 20;

int N, M;
int grid[MAX_N][MAX_N];
bool gVisited[MAX_N][MAX_N];
bool lVisited[MAX_N][MAX_N];
const vector<Vector2> OFFSET {
    {-1, 0},
    {0, 1},
    {1, 0},
    {0, -1}
};

inline bool isOutOfBound(int r, int c) {
    return r < 0 || r >= N || c < 0 || c >= N;
}

struct Group {
    Vector2 base{};
    int numNormal = 0, numRainbow = 0;
    vector<Vector2> blocks{};
    
    friend bool operator<(const Group& a, const Group& b) {
        if (a.blocks.size() != b.blocks.size()) {
            return a.blocks.size() < b.blocks.size();
        } else if (a.numRainbow != b.numRainbow) {
            return a.numRainbow < b.numRainbow;
        } else {
            return a.base < b.base;
        }
    }
};

Group bfs(int i, int j, int color) {
    memset(lVisited, 0, sizeof(lVisited));
    
    queue<Vector2> q;
    Group retval;
    {
        retval.base = {i, j};
        retval.numNormal = 1;
        retval.numRainbow = 0;
    }

    lVisited[i][j] = true;
    q.emplace(i, j);
    retval.blocks.emplace_back(i, j);

    while (!q.empty()) {
        const auto [r, c] = q.front(); q.pop();
        
        for(const auto& [dr, dc] : OFFSET) {
            int nr = r + dr, nc = c + dc;
            if (isOutOfBound(nr, nc) || lVisited[nr][nc]) {
                continue;
            }
            
            int v = grid[nr][nc];
            if (v != color && v != RAINBOW) {
                continue;
            }
            
            lVisited[nr][nc] = true;
            q.emplace(nr, nc);
            v == RAINBOW ? retval.numRainbow++ : retval.numNormal++;
            retval.blocks.emplace_back(nr,nc);
        }
    }
    
    return retval;
}

bool findBiggest(Group& best) {
    memset(gVisited, 0, sizeof(gVisited));
    bool found = false;

    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            const int color = grid[i][j];
            if (color <= RAINBOW || gVisited[i][j]) {
                continue;
            }

            Group retval = bfs(i, j, color);
            if (retval.blocks.size() < 2) { 
                continue;
            }
            
            for (const auto& [r, c] : retval.blocks) {
                if (grid[r][c] > RAINBOW)
                    gVisited[r][c] = true;
            }

            if (!found || best < retval) {
                found = true;
                best = retval;
            }
        }
    }
    
    return found;
}

int removeGroup(const Group& g) {
    for (const auto& [r, c] : g.blocks) {
        grid[r][c] = REMOVED;
    }
    
    int sz = g.blocks.size();
    return sz * sz;
}

void applyGravity() {
    for (int c = 0; c < N; ++c) {
        int write = N - 1;
        for (int r = N - 1; r >= 0; --r) {
            if (grid[r][c] == BLACK) {
                write = r - 1;
            } else if (grid[r][c] != REMOVED) {
                if (write != r) {
                    grid[write][c] = grid[r][c];
                    grid[r][c]     = REMOVED;
                }
                
                --write;
            }
        }
    }
}

void rotateCCW() {
    int tmp[MAX_N][MAX_N];
    for (int r = 0; r < N; ++r) {
        for (int c = 0; c < N; ++c) {
            tmp[N - 1 - c][r] = grid[r][c];
        }
    }
    
    memcpy(grid, tmp, sizeof(grid));
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> N >> M;
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            cin >> grid[i][j];
        }
    }
    
    int score = 0;
    Group best;
    while (true) {
        if (!findBiggest(best)) {
            break;
        }
        
        score += removeGroup(best);
        
        applyGravity();
        rotateCCW();
        applyGravity();
    }

    cout << score;
    return 0;
}

[kangrae-jo]

저도 한 2시간 ~ 2시간 30분 정도 걸린 것 같아요.
저는 가장큰 그룹을 선택하는 과정에서 비교 로직에 조금 많은 시간을 쓴 것 같아요.
이유는 따로없고... 제가 문제를 잘못읽었었습니다..

그래놓고 회전과 중력 메서드를 막 만졌네요.

그리고 제 회전 메서드를 보면 특이할 수도 있는데요.
제가 직접 생각해내어 조금 뿌듯합니다.
다른 분들도 생각해내셨겠지만 개인적인 성취감...
(예전에 비슷한 문제가 있었던 것 같기도 하네요. 카카오 열쇠 돌리기 문제였나)

어쨌든 균호님 말처럼 특별히 어려운 부분은 없었지만 시간을 아주아주 오래걸린 그런 문제네요...
좋은문제 감사합니다.

#include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <vector>

using namespace std;

const int EMPTY = -2;
const int BLACK = -1;
const int RAINBOW = 0;
const int OFFSET[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};

struct Group {
    int y = -1, x = -1;
    int normal = -1;
    int rainbow = -1;

    bool operator<(const Group& other) const {
        int b1 = normal + rainbow, b2 = other.normal + other.rainbow;
        if (b1 != b2) return b1 < b2;
        if (rainbow != other.rainbow) return rainbow < other.rainbow;
        if (normal != other.normal) return normal < other.normal;
        if (y != other.y) return y < other.y;
        return x < other.x;
    }
};

bool isIn(int y, int x, int N) { return 0 <= y && y < N && 0 <= x && x < N; }

Group getGroupSize(vector<vector<int>>& board, int y, int x, int color, int N, vector<vector<bool>>& v) {
    vector<vector<bool>> visited(N, vector<bool>(N, false));
    queue<pair<int, int>> q;
    q.push({y, x});
    visited[y][x] = true;

    Group group = {y, x, 0, 0};
    while (!q.empty()) {
        auto [curY, curX] = q.front();
        q.pop();

        if (board[curY][curX] == RAINBOW) group.rainbow++;
        else {
            v[curY][curX] = true;
            group.normal++;
        }

        for (int dir = 0; dir < 4; dir++) {
            int nextY = curY + OFFSET[dir][0];
            int nextX = curX + OFFSET[dir][1];
            if (isIn(nextY, nextX, N) && !visited[nextY][nextX] &&
                (board[nextY][nextX] == color ||
                 board[nextY][nextX] == RAINBOW)) {
                q.push({nextY, nextX});
                visited[nextY][nextX] = true;
            }
        }
    }

    return group;
}

void eraseBlock(vector<vector<int>>& board, int y, int x, int color, int N) {
    vector<vector<bool>> visited(N, vector<bool>(N, false));
    queue<pair<int, int>> q;
    q.push({y, x});
    visited[y][x] = true;

    while (!q.empty()) {
        auto [curY, curX] = q.front();
        q.pop();

        board[curY][curX] = EMPTY;

        for (int dir = 0; dir < 4; dir++) {
            int nextY = curY + OFFSET[dir][0];
            int nextX = curX + OFFSET[dir][1];
            if (isIn(nextY, nextX, N) && !visited[nextY][nextX] &&
                (board[nextY][nextX] == color ||
                 board[nextY][nextX] == RAINBOW)) {
                q.push({nextY, nextX});
                visited[nextY][nextX] = true;
            }
        }
    }
}

void moveDown(vector<vector<int>>& board, int N) {
    for (int x = 0; x < N; x++) {
        for (int y = N - 2; y >= 0; y--) {
            if (board[y][x] != EMPTY && board[y][x] != BLACK) {
                int offset = 1;
                while (y + offset < N) {
                    if (board[y + offset][x] == EMPTY) offset++;
                    else break;
                }
                if (y + offset - 1 != y) {
                    board[y + offset - 1][x] = board[y][x];
                    board[y][x] = EMPTY;
                }
            }
        }
    }
}

vector<vector<int>> rotate(vector<vector<int>>& board, int N) {
    vector<vector<int>> rotated(N, vector<int>(N, EMPTY));
    for (int y = 0; y < N; y++) {
        for (int x = 0; x < N; x++) {
            rotated[abs(x - N + 1)][y] = board[y][x];
        }
    }
    return rotated;
}

int main() {
    int N, M;
    cin >> N >> M;

    vector<vector<int>> board(N, vector<int>(N));
    for (int y = 0; y < N; y++) {
        for (int x = 0; x < N; x++) {
            cin >> board[y][x];
        }
    }

    int score = 0;
    while (true) {
        vector<vector<bool>> visited(N, vector<bool>(N, false));

        Group largest;
        for (int y = 0; y < N; y++) {
            for (int x = 0; x < N; x++) {
                if (!visited[y][x] && board[y][x] != BLACK &&
                    board[y][x] != EMPTY && board[y][x] != RAINBOW) {
                    Group temp = getGroupSize(board, y, x, board[y][x], N, visited);
                    if (largest < temp) largest = temp;
                }
            }
        }
        if (largest.normal == 0 || largest.normal + largest.rainbow < 2) break;

        score += (largest.normal + largest.rainbow) * (largest.normal + largest.rainbow);
        
        eraseBlock(board, largest.y, largest.x, board[largest.y][largest.x], N);
        moveDown(board, N);
        board = rotate(board, N);
        moveDown(board, N);
    }

    cout << score;

    return 0;
}

[kangrae-jo]

빅토르 e 메서드가 직관적이고 깔끔하네요.
저는 살짝 이해하기는 쉽지만 지저분한 코드가 된 것 같기도 해요.
장보고갑니다.

[wnsmir]

후... 다시풀어도 한시간 좀 덜걸리네요
고생하셨습니다

from collections import deque

def bfs(grid):
    N = len(grid)
    dx = [1, -1, 0, 0]
    dy = [0, 0, 1, -1]
    visited = [[-1]*N for _ in range(N)]
    max_blocks = []
    max_rainbow = 0

    for x in range(N):
        for y in range(N):
            color = None
            blocks = []
            rainbow = 0

            # 시작 칸이 일반 블록이 아니면 건너뛰기
            if grid[x][y] <= 0:
                continue
            else:
                queue = deque()
                queue.append((x, y))
                blocks.append((x, y))
                visited[x][y] = 1
                color = grid[x][y]

            while queue:
                cx, cy = queue.popleft()
                for i in range(4):
                    nx, ny = cx + dx[i], cy + dy[i]
                    if 0 <= nx < N and 0 <= ny < N and visited[nx][ny] == -1:
                        # 무지개 블록
                        if grid[nx][ny] == 0:
                            queue.append((nx, ny))
                            blocks.append((nx, ny))
                            rainbow += 1
                            visited[nx][ny] = 2
                        # 일반 블록이면서 색이 같은 경우
                        elif grid[nx][ny] != -1 and color is not None and grid[nx][ny] == color:
                            queue.append((nx, ny))
                            visited[nx][ny] = 1
                            blocks.append((nx, ny))

            # 무지개 블록만 다시 미방문으로
            for i in range(N):
                for j in range(N):
                    if visited[i][j] == 2:
                        visited[i][j] = -1

            # 그룹 최소 조건 검사
            if color is None or len(blocks) < 2:
                continue

            # 그룹 우선순위 비교: 크기 → 무지개 수 → 기준 블록
            if len(max_blocks) < len(blocks):
                max_blocks = blocks[:]
                max_rainbow = rainbow

            elif len(max_blocks) == len(blocks):
                if rainbow > max_rainbow:
                    max_blocks = blocks[:]
                    max_rainbow = rainbow

                elif rainbow == max_rainbow:
                    max_std = (N, N)
                    for bx, by in max_blocks:
                        if grid[bx][by] > 0:
                            if (bx < max_std[0]) or (bx == max_std[0] and by < max_std[1]):
                                max_std = (bx, by)

                    cur_std = (N, N)
                    for bx, by in blocks:
                        if grid[bx][by] > 0:
                            if (bx < cur_std[0]) or (bx == cur_std[0] and by < cur_std[1]):
                                cur_std = (bx, by)

                    if (cur_std[0] > max_std[0]) or (cur_std[0] == max_std[0] and cur_std[1] > max_std[1]):
                        max_blocks = blocks[:]
                        max_rainbow = rainbow

    # 가능한 그룹을 다 찾은 뒤
    if not max_blocks:
        return False

    score = len(max_blocks) * len(max_blocks)
    for bx, by in max_blocks:
        grid[bx][by] = -2
    return score

def gravity(grid):
    N = len(grid)
    for x in range(N-2, -1, -1):
        for y in range(N):
            if grid[x][y] < 0:
                continue
            nx = x
            while nx + 1 < N and grid[nx + 1][y] == -2:
                grid[nx+1][y], grid[nx][y] = grid[nx][y], -2
                nx += 1

def rotate(grid):
    N = len(grid)
    new_grid = [[0]*N for _ in range(N)]
    for i in range(N):
        for j in range(N):
            new_grid[N-j-1][i] = grid[i][j]
    for i in range(N):
        for j in range(N):
            grid[i][j] = new_grid[i][j]

N, M = map(int, input().split())
grid = [list(map(int, input().split())) for _ in range(N)]
total_score = 0

while True:
    score = bfs(grid)
    if score is False:
        print(total_score)
        break

    total_score += score
    gravity(grid)
    rotate(grid)
    gravity(grid)

[kokeunho]

신경써야할 조건이 많기도 하고 반환해야 할 값도 많아서
많이 헷갈린 문제였습니다.

사실 아래 코드로 제출했을 때,
1프로 못채우고 오답이 떴는데 도저히 해결못하겠어서 포기합니다;
예제 입출력은 맞게 나오는데 뭐가 문제일까요

code

import java.util.*;

public class Main {
    static int N, M;
    static int[][] map;
    static boolean[][] visited;
    static final int EMPTY = -2;
    static int[] dx = {-1, 1, 0, 0};
    static int[] dy = {0, 0, -1, 1};

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        N = sc.nextInt();
        M = sc.nextInt();

        map = new int[N][N];
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                map[i][j] = sc.nextInt();
            }
        }

        int score = 0;
        while (true) {
            BlockGroup group = findBiggestGroup();
            if (group == null || group.blocks.size() < 2) break;

            for (int[] pos : group.blocks) map[pos[0]][pos[1]] = EMPTY;

            score += group.blocks.size() * group.blocks.size();

            gravity();
            rotate();;
            gravity();
        }
        System.out.println(score);
    }
    static class BlockGroup implements Comparable<BlockGroup> {
        List<int[]> blocks;
        int rainbowCount;
        int standardRow, standardCol;

        public BlockGroup(List<int[]> blocks, int rainbowCount, int standardRow, int standardCol) {
            this.blocks = blocks;
            this.rainbowCount = rainbowCount;
            this.standardRow = standardRow;
            this.standardCol = standardCol;
        }

        @Override
        public int compareTo(BlockGroup o) {
            if (this.blocks.size() != o.blocks.size()) return o.blocks.size() - this.blocks.size();
            if (this.rainbowCount != o.rainbowCount) return o.rainbowCount - this.rainbowCount;
            if (this.standardRow != o.standardRow) return o.standardRow - this.standardRow;
            return o.standardCol - this.standardCol;
        }
    }
    static BlockGroup findBiggestGroup() {
        visited = new boolean[N][N];
        BlockGroup biggest = null;

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (map[i][j] <= 0 || visited[i][j]) continue;

                BlockGroup group = bfs(i, j, map[i][j]);
                if (group.blocks.size() >= 2) {
                    if (biggest == null || group.compareTo(biggest) < 0) {
                        biggest = group;
                    }
                }
            }
        }
        return biggest;
    }
    static BlockGroup bfs(int x, int y, int color) {
        Queue<int[]> queue = new LinkedList<>();
        List<int[]> blocks = new ArrayList<>();
        boolean[][] tempVisited = new boolean[N][N];
        int rainbowCount = 0;

        queue.add(new int[]{x, y});
        blocks.add(new int[]{x, y});
        visited[x][y] = true;
        tempVisited[x][y] = true;

        while (!queue.isEmpty()) {
            int[] current = queue.poll();;
            for (int i = 0; i < 4; i++) {
                int nx = current[0] + dx[i];
                int ny = current[1] + dy[i];
                if (nx >= 0 && nx < N && ny >= 0 && ny < N && !tempVisited[nx][ny]
                        && (map[nx][ny] == color || map[nx][ny] == 0)) {
                    queue.add(new int[]{nx, ny});
                    blocks.add(new int[]{nx, ny});
                    tempVisited[nx][ny] = true;
                    if (map[nx][ny] != 0) visited[nx][ny] = true;
                    if (map[nx][ny] == 0) rainbowCount++;
                }
            }
        }

        int standardRow = -1, standardCol = -1;
        for (int[] pos : blocks) {
            int i = pos[0], j = pos[1];
            if (map[i][j] == 0) {
                visited[i][j] = false;
                continue;
            }
            if (standardRow < i || (standardRow == i && standardCol < j)) {
                standardRow = i;
                standardCol = j;
            }
        }
        return new BlockGroup(blocks, rainbowCount, standardRow, standardCol);
    }
    static void gravity() {
        for (int j = 0; j < N; j++) {
            for (int i = N - 2; i >= 0; i--) {
                if (map[i][j] < 0) continue;
                int r = i;
                while (r + 1 < N && map[r+1][j] == EMPTY) {
                    if (map[r][j] == -1) break;

                    map[r+1][j] = map[r][j];
                    map[r][j] = EMPTY;
                    r++;
                }
            }
        }
    }
    static void rotate() {
        int[][] newMap = new int[N][N];
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                newMap[N-1-j][i] = map[i][j];
            }
        }
        map = newMap;
    }
}

[g0rnn]

신경써야할 조건이 많기도 하고 반환해야 할 값도 많아서 많이 헷갈린 문제였습니다.

사실 아래 코드로 제출했을 때, 1프로 못채우고 오답이 떴는데 도저히 해결못하겠어서 포기합니다; 예제 입출력은 맞게 나오는데 뭐가 문제일까요

근호님 고생하셨습니다. 메서드 분리가 잘 되어있어서 읽기 쉬웠어요.

문제가 구현해야할 사소한 조건이 많아서 정답을 도출하는데 더 어려워졌다고 생각합니다. 제가 찾은 몇가지 수정사항을 먼저 알려드리자면

1. rotate 메서드가 반시계 방향이 아니라 시계방향입니다.

newMap[j][N - 1 - i] = map[i][j];

와 같이 수정해야합니다.

2. 기준 블록 좌표가 행이 작은순 -> 같다면 열이 작은순이 아님

if (standardRow == -1 || i < standardRow || (i == standardRow && j < standardCol)) {
    standardRow = i;
    standardCol = j;
}

이거 수정하면 테스트 케이스부터 실패하긴합니다.. 아마 테케 통과된건 우연이 아닐까 하는 조심스러운 생각..