67-9kyo-hwang #228

9kyo-hwang · 2024-09-22T16:10:15Z

🔗 문제 링크

퍼즐 조각 채우기

테이블에 놓인 블록을 게임 보드의 빈 공간에 올려놓아야 한다. 이 때, 다음 규칙을 따라야 한다.

조각은 한 번에 하나씩 채워 넣는다
조각을 회전시킬 수 있다
조각을 뒤집을 수 없다
게임 보드에 새로 채워 넣은 블럭과 인접한 칸이 비어있으면 안된다.

위와 같이 3, 4, 5번 블럭을 격자 칸에 놓으면 규칙에 어긋나 불가능하다.

규칙에 맞게 최대한 많은 블럭을 채워 넣으면 위와 같으며, 총 14칸을 채울 수 있다.

규칙에 맞게 최대한 많은 퍼즐 조각을 채워 넣을 경우, 총 몇 칸을 채울 수 있는지 return 하도록 함수를 완성하라.

✔️ 소요된 시간

모름. 매우 오래 걸림

✨ 수도 코드

문제에서 퍼즐 조각은 최대 6개까지만 주어진다고 했으므로, 보드와 테이블에서 퍼즐 조각 정보를 저장한 뒤 전수 검사하는 방식을 사용한다.

우선 퍼즐 조각 정보를 얻어내는 것은 DFS/BFS 방식으로 가능하다. 2차원 배열에서 그래프 연결 요소 알아내는 것처럼 구해낼 수 있다.

using FPoint = pair<int, int>;

vector<vector<FPoint>> GetBlocksFrom(vector<vector<int>>& Board, bool IsBoard = true)
{
    const vector<FPoint> Offset{{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
    auto OutOfBound = [&](int x, int y)
    {
        return x < 0 || x >= Board.size() || y < 0 || y >= Board.size();
    };
    
    vector<vector<FPoint>> Blocks;
    
    function<void(int, int)> DFS = [&](int x, int y)  // 블럭은 DFS 방식으로 인접 칸을 검사하며 좌표를 얻어온다.
    {
        Blocks.back().emplace_back(x, y);
        Board[x][y] = (IsBoard ? 1 : 0);

        for(const auto& [dx, dy] : Offset)
        {
            int nx = x + dx, ny = y + dy;
            if(!OutOfBound(nx, ny) && Board[nx][ny] == (IsBoard ? 0 : 1))
            {
                DFS(nx, ny);
            }
        }
    };
    
    for(int i = 0; i < Board.size(); ++i)
    {
        for(int j = 0; j < Board.size(); ++j)
        {
            if(IsBoard && Board[i][j] == 0  // game_board의 경우 빈 칸
              || !IsBoard && Board[i][j] == 1)  // table의 경우 채워진 칸
            {
                Blocks.push_back({});
                DFS(i, j);
            }
        }
    }
    
    return Blocks;
}

다만 game_board와 table에서 모두 추출해내야 하는데, 게임 보드는 빈 칸 / 테이블은 채워진 칸이므로 이를 구분해주는 플래그 IsBoard를 통해 구분한다.

이 함수를 이용해 다음과 같이 game_board에 대한 블럭들과 table에 대한 블럭들 정보를 얻는다.

vector<vector<FPoint>> BoardBlocks = GetBlocksFrom(InGameBoard, true);
vector<vector<FPoint>> TableBlocks = GetBlocksFrom(InTable, false);

이제 이렇게 얻은 조각들을 가지고 전수 조사를 시작한다. 모든 보드 블럭들에 대해, 테이블 블럭을 하나씩 회전시키며 확인한다.

for(const vector<FPoint>& BoardBlock : BoardBlocks)  // 모든 보드 블럭에 대해
{
    ....
    
    for(const vector<FPoint>& TableBlock : TableBlocks)  // 테이블 블럭을 하나씩 비교해본다.
    {
        ....  // 이 때 회전도 같이 할 것
    }
}

이러한 로직으로 진행되는데, 문제는 "블럭끼리 어떻게 비교할 것인가"이다. 나는 여기서 얻어낸 블럭들을 2차원 배열로 가공 처리했다.

예를 들어 예시 그림에서 주어진 2번 블럭의 경우 이런 식으로 변환한다.

vector<vector<int>> GetGridFrom(const vector<FPoint>& Block)
{
    auto [MinX, MinY] = Block[0];
    auto [MaxX, MaxY] = Block[0];

    for(const auto& [x, y] : Block)
    {
        if(x < MinX) MinX = x;
        else if(x > MaxX) MaxX = x;

        if(y < MinY) MinY = y;
        else if(y > MaxY) MaxY = y;
    }

    vector<vector<int>> Grid(MaxX - MinX + 1, vector<int>(MaxY - MinY + 1, 0));
    for(const auto& [x, y] : Block)
    {
        Grid[x - MinX][y - MinY] = 1;
    }
    
    return Grid;
}

이 과정은 들고 있는 좌표들의 최대, 최소 x/y 좌표값을 이용해 구현할 수 있다.

마지막으로 남은 건 블럭의 "회전" 기능이다.

이는 다음과 같은 좌표 변환으로 가능하다: [x, y] -> [y, N - 1 - x](N: 2차원 행렬의 행 크기)

(0, 0) -> (0, 2), (0, 1) -> (1, 2), (0, 2) -> (2, 2)
(1, 0) -> (0, 1), (1, 1) -> (1, 1), (1, 2) -> (2, 1)
(2, 0) -> (0, 0), (2, 1) -> (1, 0), (2, 2) -> (2, 0)

int Rotate(vector<vector<int>>& Grid)
{
    vector<vector<int>> Rotated(Grid[0].size(), vector<int>(Grid.size(), 0));
    int NumCell = 0;
    
    for(int i = 0; i < Grid.size(); ++i)
    {
        for(int j = 0; j < Grid[0].size(); ++j)
        {
            if(Grid[i][j] == 1) NumCell++;
            Rotated[j][Grid.size() - 1 - i] = Grid[i][j];
        }
    }
    
    Grid = Rotated;  // 90도 회전한 블럭은 기존에 넘겨받은 블럭을 대체함
    return NumCell;  // 현재 블럭은 몇 칸짜리인 지 반환
}

준비가 완료되었으니, 모든 블럭끼리 회전을 하면서 비교한다.

set<vector<FPoint>> UsedTableBlocks;  // 사용된 테이블 블럭을 구분하기 위한 Set
int Answer = 0;

for(const vector<FPoint>& BoardBlock : BoardBlocks)  // 보드의 블럭을 순회함
{
    bool IsFilled = false;
    vector<vector<int>> BoardBlockGrid = GetGridFrom(BoardBlock);  // 2차원 배열 형태로 변환
    
    for(const vector<FPoint>& TableBlock : TableBlocks)
    {
        if(IsFilled) break;  // 이전 테이블 블럭에 의해 채워졌다면 더 이상 확인하지 않음
        if(UsedTableBlocks.count(TableBlock)) continue;  // 앞선 비교에서 이미 사용된 테이블 블럭이라면 Skip
        
        vector<vector<int>> TableBlockGrid = GetGridFrom(TableBlock);  // 2차원 배열 형태로 변환
        for(int i = 0; i < 4; ++i)  // 4번 회전
        {
            int NumCell = Rotate(TableBlockGrid);
            if(BoardBlockGrid == TableBlockGrid)  // 회전한 결과와 일치하다면
            {
                Answer += NumCell;
                UsedTableBlocks.emplace(TableBlock);
                IsFilled = true;
                break;
            }
        }
    }
}

return Answer;

전체 코드

#include <string>
#include <vector>
#include <functional>
#include <set>

using namespace std;
using FPoint = pair<int, int>;

vector<vector<FPoint>> GetBlocksFrom(vector<vector<int>>& Board, bool IsBoard = true)
{
    const vector<FPoint> Offset{{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
    auto OutOfBound = [&](int x, int y)
    {
        return x < 0 || x >= Board.size() || y < 0 || y >= Board.size();
    };
    
    vector<vector<FPoint>> Blocks;
    
    function<void(int, int)> DFS = [&](int x, int y)
    {
        Blocks.back().emplace_back(x, y);
        Board[x][y] = (IsBoard ? 1 : 0);

        for(const auto& [dx, dy] : Offset)
        {
            int nx = x + dx, ny = y + dy;
            if(!OutOfBound(nx, ny) && Board[nx][ny] == (IsBoard ? 0 : 1))
            {
                DFS(nx, ny);
            }
        }
    };
    
    for(int i = 0; i < Board.size(); ++i)
    {
        for(int j = 0; j < Board.size(); ++j)
        {
            if(IsBoard && Board[i][j] == 0
              || !IsBoard && Board[i][j] == 1)
            {
                Blocks.push_back({});
                DFS(i, j);
            }
        }
    }
    
    return Blocks;
}

vector<vector<int>> GetGridFrom(const vector<FPoint>& Block)
{
    auto [MinX, MinY] = Block[0];
    auto [MaxX, MaxY] = Block[0];

    for(const auto& [x, y] : Block)
    {
        if(x < MinX) MinX = x;
        else if(x > MaxX) MaxX = x;

        if(y < MinY) MinY = y;
        else if(y > MaxY) MaxY = y;
    }

    vector<vector<int>> Grid(MaxX - MinX + 1, vector<int>(MaxY - MinY + 1, 0));
    for(const auto& [x, y] : Block)
    {
        Grid[x - MinX][y - MinY] = 1;
    }
    
    return Grid;
}

int Rotate(vector<vector<int>>& Grid)
{
    vector<vector<int>> Rotated(Grid[0].size(), vector<int>(Grid.size(), 0));
    int NumCell = 0;
    
    for(int i = 0; i < Grid.size(); ++i)
    {
        for(int j = 0; j < Grid[0].size(); ++j)
        {
            if(Grid[i][j] == 1) NumCell++;
            Rotated[j][Grid.size() - 1 - i] = Grid[i][j];
        }
    }
    
    Grid = Rotated;
    return NumCell;
}

int solution(vector<vector<int>> InGameBoard, vector<vector<int>> InTable) 
{
    vector<vector<FPoint>> BoardBlocks = GetBlocksFrom(InGameBoard, true);
    vector<vector<FPoint>> TableBlocks = GetBlocksFrom(InTable, false);
    
    set<vector<FPoint>> UsedTableBlocks;
    int Answer = 0;
    
    for(const vector<FPoint>& BoardBlock : BoardBlocks)
    {
        bool IsFilled = false;
        vector<vector<int>> BoardBlockGrid = GetGridFrom(BoardBlock);
        
        for(const vector<FPoint>& TableBlock : TableBlocks)
        {
            if(IsFilled) break;
            if(UsedTableBlocks.count(TableBlock)) continue;
            
            vector<vector<int>> TableBlockGrid = GetGridFrom(TableBlock);
            for(int i = 0; i < 4; ++i)
            {
                int NumCell = Rotate(TableBlockGrid);
                if(BoardBlockGrid == TableBlockGrid)
                {
                    Answer += NumCell;
                    UsedTableBlocks.emplace(TableBlock);
                    IsFilled = true;
                    break;
                }
            }
        }
    }
    
    return Answer;
}

📚 새롭게 알게된 내용

프로그래머스 그래프 순회 카테고리에 있는 건데 한 번쯤 풀어봐야지... 하고 냅뒀다가 풀어보게 됐는데
후... 너무 화난다. 중간에 블로그 참고를 몇 번이나 했는지 모르겠다. 시간도 왕창 날려먹었다.

mjj111

첫 번째 트라이

import java.util.*;
class Solution {

    private static int N;
    private static int[] dx = {0, 0, -1, 1};
    private static int[] dy = {1, -1, 0, 0};
    private static Map<Integer, Integer> blocks;
    private static boolean[][] visited;
    private static int answer;
    private static int[][] table;
    private static int[][] game_board;

    public int solution(int[][] game_board, int[][] table) {
        this.table = table;
        this.game_board = game_board;
        N = table.length;
        answer = 0;
        blocks = new HashMap<>();
        visited = new boolean[N][N];
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (!visited[i][j] && table[i][j] == 1) {
                    count(i, j);
                }
            }
        }
        visited = new boolean[N][N];
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (!visited[i][j] && game_board[i][j] == 0) { 
                    bfs(i, j);
                }
            }
        }
        return answer;
    }
    private static void bfs(int gx, int gy) {
        visited[gx][gy] = true;
        Deque<int[]> dq = new LinkedList<>();
        dq.addLast(new int[]{gx, gy});
        int count = 0; 
        while (!dq.isEmpty()) {
            count++;
            int[] now = dq.removeFirst();
            int x = now[0];
            int y = now[1];

            for (int i = 0; i < 4; i++) {
                int nx = x + dx[i];
                int ny = y + dy[i];
                if (isOut(nx, ny)) continue;
                if (visited[nx][ny]) continue;
                if (game_board[nx][ny] != 0) continue;
                visited[nx][ny] = true;
                dq.addLast(new int[]{nx, ny});
            }
        }

        if (blocks.containsKey(count) && blocks.get(count) > 0) {
            answer += count; 
            blocks.put(count, blocks.get(count) - 1);
        }
    }
    private static void count(int gx, int gy) {
        visited[gx][gy] = true;
        Deque<int[]> dq = new LinkedList<>();
        dq.addLast(new int[]{gx, gy});
        int count = 0; 
        while (!dq.isEmpty()) {
            count++; 
            int[] now = dq.removeFirst();
            int x = now[0];
            int y = now[1];
            for (int i = 0; i < 4; i++) {
                int nx = x + dx[i];
                int ny = y + dy[i];
                if (isOut(nx, ny)) continue;
                if (visited[nx][ny]) continue;
                if (table[nx][ny] != 1) continue;
                visited[nx][ny] = true;
                dq.addLast(new int[]{nx, ny});
            }
        }
        blocks.put(count, blocks.getOrDefault(count, 0) + 1);
    }
    private static boolean isOut(int x, int y) {
        return x < 0 || x >= N || y < 0 || y >= N;
    }
}

아.. 문제를 잘못 읽어서 20분 날리고 다시 풀었네요..ㅠㅠ
표준화하는데 흰머리 나고,, 이게 또 맞는지 생각하는데 흰머리 또 났습니다..
board 크기가 50으로 작아서 Set 생성하고 활용해서 풀었습니당
++이게 왜 level3죠...

두 번째 트라이

import java.util.*;

class Solution {
    private static final int[] dx = {-1, 1, 0, 0};
    private static final int[] dy = {0, 0, -1, 1};
    private static int N;
    
    public int solution(int[][] game_board, int[][] table) {
        N = game_board.length;
        List<List<int[]>> emptySpaces = findBlocks(game_board, 0);
        List<List<int[]>> puzzlePieces = findBlocks(table, 1);
        
        boolean[] used = new boolean[puzzlePieces.size()];
        int answer = 0;

        for (List<int[]> space : emptySpaces) {
            for (int i = 0; i < puzzlePieces.size(); i++) {
                if (used[i]) continue;
                List<int[]> piece = puzzlePieces.get(i);
                if (canFit(space, piece)) {
                    used[i] = true;
                    answer += piece.size();
                    break;
                }
            }
        }

        return answer;
    }

    private List<List<int[]>> findBlocks(int[][] board, int target) {
        boolean[][] visited = new boolean[N][N];
        List<List<int[]>> blocks = new ArrayList<>();

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if(board[i][j] != target) continue;
                if(visited[i][j]) continue;
                
                List<int[]> block = new ArrayList<>();
                dfs(board, i, j, visited, block, target);
                normalize(block);
                blocks.add(block);
            }
        }

        return blocks;
    }

    private void dfs(int[][] board, int x, int y, boolean[][] visited, List<int[]> block, int target) {
        if (x < 0 || x >= N || y < 0 || y >= N ||
            visited[x][y] || board[x][y] != target) {
            return;
        }

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

        for (int i = 0; i < 4; i++) {
            dfs(board, x + dx[i], y + dy[i], visited, block, target);
        }
    }

    private void normalize(List<int[]> block) {
        int minX = Integer.MAX_VALUE;
        int minY = Integer.MAX_VALUE;
        
        for (int[] point : block) {
            minX = Math.min(minX, point[0]);
            minY = Math.min(minY, point[1]);
        }
        for (int[] point : block) {
            point[0] -= minX;
            point[1] -= minY;
        }
    }

    private boolean canFit(List<int[]> space, List<int[]> piece) {
        if (space.size() != piece.size()) return false;

        for (int rot = 0; rot < 4; rot++) {
            if (isSameShape(space, piece)) return true;
            rotate(piece);
        }

        return false;
    }

    private boolean isSameShape(List<int[]> shape1, List<int[]> shape2) {
        Set<String> set1 = new HashSet<>();
        Set<String> set2 = new HashSet<>();

        for (int[] point : shape1) set1.add(point[0] + "," + point[1]);
        for (int[] point : shape2) set2.add(point[0] + "," + point[1]);

        return set1.equals(set2);
    }

    private void rotate(List<int[]> piece) {
        for (int[] point : piece) {
            int temp = point[0];
            point[0] = point[1];
            point[1] = -temp;
        }
        normalize(piece);
    }
}

gjsk132

문제보자마자 머리 아파오는 문제... table에 있는 block만 뽑아내고, board에 넣는건... 포기했습니다🥲 그냥 냅다 다 돌리면 되는거였군요...

PR 참고해서 스스슥 해결하고 갑니다!
저는 그냥 set 안 쓰고 슥삭 햇습니다

와장창

def solution(game_board, table):
    
    puzzles, emptys = [], []

    offset = [(-1, 0), (0, 1), (1, 0), (0, -1)]

    tx, ty = len(table), len(table[0])
    gx, gy = len(game_board), len(game_board[0])

    def dfs_table(x, y):
        
        puzzle = [(x, y)]

        for dx, dy in offset:
            nx, ny = x + dx, y + dy
            
            if not 0 <= nx < tx or not 0 <= ny < ty:
                continue

            if table[nx][ny] == 0 or table[nx][ny] == 2:
                continue

            table[nx][ny] = 2

            puzzle += dfs_table(nx, ny)

        return puzzle
    
    def dfs_board(x, y):
        
        empty = [(x, y)]

        for dx, dy in offset:
            nx, ny = x + dx, y + dy
            
            if not 0 <= nx < gx or not 0 <= ny < gy:
                continue

            if game_board[nx][ny] == 1 or game_board[nx][ny] == 2:
                continue

            game_board[nx][ny] = 2

            empty += dfs_board(nx, ny)

        return empty

    def stadnard(space):
        dx = min([i[0] for i in space])
        dy = min([i[1] for i in space])
        h = max([i[0] for i in space]) - dx + 1
        w = max([i[1] for i in space]) - dy + 1

        grid = [[0]*w for _ in range(h)]

        for x, y in space:
            grid[x-dx][y-dy] = 1

        return grid

        grid = [list(e) for e in zip(*grid[::-1])]

    num = 0
    for i in range(tx):
        for j in range(ty):
            if table[i][j] == 1:
                table[i][j] = 2 
                num += 1
                puzzles.append(stadnard(dfs_table(i, j)))

    for i in range(gx):
        for j in range(gy):
            if game_board[i][j] == 0:
                game_board[i][j] = 2 
                emptys.append(stadnard(dfs_board(i, j)))
                
    result = 0
    is_use = [False]*len(puzzles)
    
    for e in emptys:
        is_empty = True

        for idx, p in enumerate(puzzles):
            if is_use[idx]:
                continue

            cnt = 4
            while cnt:
                if e == p:
                    result += sum([sum(i) for i in e])
                    is_use[idx] = True
                    is_empty = False
                    break
                else:
                    p = [list(e) for e in zip(*p[::-1])]
                    cnt -= 1

            if not is_empty:
                break

    return result

9kyo-hwang added 5 commits September 3, 2024 22:10

63-9kyo-hwang

abe7706

64-9kyo-hwang

b9a906d

65-9kyo-hwang

bf8edb7

66-9kyo-hwang

086f215

67-9kyo-hwang

e172cbf

9kyo-hwang added 9-kyo-hwang 리뷰 기다리는 중 🔥 labels Sep 22, 2024

9kyo-hwang requested review from mjj111, gjsk132 and xxubin04 September 22, 2024 16:10

9kyo-hwang self-assigned this Sep 22, 2024

mjj111 approved these changes Oct 2, 2024

View reviewed changes

gjsk132 approved these changes Oct 7, 2024

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

67-9kyo-hwang #228

67-9kyo-hwang #228

9kyo-hwang commented Sep 22, 2024 •

edited

Loading

mjj111 left a comment •

edited

Loading

gjsk132 left a comment

67-9kyo-hwang #228

Are you sure you want to change the base?

67-9kyo-hwang #228

Conversation

9kyo-hwang commented Sep 22, 2024 • edited Loading

🔗 문제 링크

퍼즐 조각 채우기

✔️ 소요된 시간

모름. 매우 오래 걸림

✨ 수도 코드

📚 새롭게 알게된 내용

mjj111 left a comment • edited Loading

Choose a reason for hiding this comment

gjsk132 left a comment

Choose a reason for hiding this comment

9kyo-hwang commented Sep 22, 2024 •

edited

Loading

mjj111 left a comment •

edited

Loading