34-wnsmir

[wnsmir]

🔗 문제 링크

https://www.acmicpc.net/problem/15685

✔️ 소요된 시간

1h

✨ 수도 코드

상어를 잡기전 몸풀기문제로 한번 풀어보았습니다.
이 문제에서 생각했던점은 딱 두가지였습니다.

중심점이 있는 상태에서의 회전, 마지막 좌표 즉 다음 중심점을 어떻게 업데이트해주어야 할 것인가?

중심점이 있는 회전은

def rot90(p, pivot):
    x, y = p
    px, py = pivot
    return (px - (y - py), py + (x - px))

이렇게 처리해주었습니다.

다음 중심점을 처리하는게 좀 시간이 많이 걸렸는데 처음에는 시작점에서 bfs로 가장멀리있는 점을 찾아서 매번 업데이트시켜줄까 했지만 너무 투머치인것 같아 좀더 생각해본 결과

회전해서 새 리스트에 추가해줄때 중심점으로 부터 가까운점들부터 추가해주면 마지막에 추가되는점이 마지막점이 되는 점을 이용했습니다.
즉 중심점으로부터 가까운점을 먼저 추가해주려면 이전세대의 점들을 뒤에서부터 순회하며 세 세대 뒤에 하나씩 추가해줍니다.

그럼 제일 마지막원소가 늘 다음 회전의 중심점이 됩니다.

이후 구현은 쉽게 하실 수 있을겁니다!
I, j를 순회하며 오른쪽, 아래, 오른쪽아래 3점이 모두 1이면 answer += 1 하도록 간단하게 구현했습니다.
(늘 우하향하기 뗴문에 중복없음)

아 참고로 x y의 방향이 일반적이 문제와는 반대여서 신경써주어야 합니다.

N = int(input())
grid = [[0]*101 for _ in range(101)]

def rot90(p, pivot):
    x, y = p
    px, py = pivot
    return (px - (y - py), py + (x - px))

def curve(last_gen, last_spot):
    new_gen = last_gen[:]
    for dot in reversed(last_gen[:-1]): # 중심 제외 역순으로
        nx, ny = rot90(dot, last_spot)
        if 0 <= nx <= 100 and 0 <= ny <= 100:
            grid[ny][nx] = 1
        new_gen.append((nx, ny))
    return new_gen, new_gen[-1]

for _ in range(N):
    x, y, d, g = map(int, input().split())

    last_gen = [(x, y)]
    grid[y][x] = 1

    # 0세대 만들기
    if d == 0:
        last_spot = (x+1, y)
    elif d == 1:
        last_spot = (x, y-1)
    elif d == 2:
        last_spot = (x-1, y)
    else:
        last_spot = (x, y+1)

    last_gen.append(last_spot)
    lx, ly = last_spot
    if 0 <= lx <= 100 and 0 <= ly <= 100:
        grid[ly][lx] = 1

    # g 세대수만큼
    for _ in range(g):
        last_gen, last_spot = curve(last_gen, last_spot)

# 사각형 개수
answer = 0
for y in range(100):
    for x in range(100):
        if grid[y][x] == 1 and grid[y][x+1] == 1 and grid[y+1][x] == 1 and grid[y+1][x+1] == 1:
            answer += 1

print(answer)

[9kyo-hwang]

문제 자체를 도저히 이해 못하겠어서 PR을 바로 봤는데도 이해가 안갔습니다... 그래서 다른 블로그를 보니까 아예 다른 방식으로 접근하더라구요.

방향 오른쪽을 0, 위를 1, 왼쪽을 2, 아래쪽을 3이라 매핑하고 문제에서 주어진 예시를 확인해보면, 아래와 같이 이동합니다.

gen 0: 0
gen 1: 0 1
gen 2: 0 1 2 1
gen 3: 0 1 2 1 2 3 2 1

세대가 증가할 때마다 방향 정보가 2배씩 늘어나는데, 이를 대칭적으로 확인해보면 다음과 같습니다.

gen 1: 0 1
gen 2: 0 1 / 2 1

gen 2: 0 1 2 1
gen 3: 0 1 2 1 / 2 3 2 1

봐도 모르겠습니다. 더 들어가보겠습니다. 한 번 다음 세대의 뒤 절반을 뒤집어보겠습니다.

gen 1: 0 1
gen 2: 0 1 / 1 2

gen 2: 0 1 2 1
gen 3: 0 1 2 1 / 1 2 3 2

이제야 좀 보입니다. 뒤 절반은 이전 세대 방향 정보에 +1을 한 것을 역순으로 나열한 것입니다. 3 -> 4를 가는 경우에만 모듈러 연산을 통해 0으로 돌리면 됩니다.

이거를 기반으로 코드를 작성하면 다음과 같습니다.

Details

#include <bits/stdc++.h>
using namespace std;

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

    int N; cin >> N;
    vector<vector<bool>> board(101, vector<bool>(101, false));
    array<int, 4> dx{0, -1, 0, 1};  // R U L D
    array<int, 4> dy{1, 0, -1, 0};
    
    int x, y, d, g;
    while(N--) {
        cin >> y >> x >> d >> g;
        vector<int> directions;
        directions.reserve(1 << g);
        
        board[x][y] = true;
        
        x += dx[d]; y += dy[d];
        board[x][y] = true;
        directions.push_back(d);
        
        while(g--) {
            for(auto it = directions.rbegin(); it != directions.rend(); ++it) {
                int nd = (*it + 1) & 0b11;
                x += dx[nd]; y += dy[nd];
                board[x][y] = true;
                directions.push_back(nd);
            }
        }
    }
    
    int ans = 0;
    for(int i = 1; i < 100; ++i) {
        for(int j = 1; j < 100; ++j) {
            if(board[i][j] && board[i + 1][j] && board[i][j + 1] && board[i + 1][j + 1]) {
                ++ans;
            }
        }
    }
    
    cout << ans;

    return 0;
}

결론: shit!

[kokeunho]

저도 이 문제를 며칠전에 풀어봤습니다.
처음 봤을 때 저도 도저히 이전 세대의 모양을 어떻게 회전 시켜야할지 떠올릴 수 없었습니다.

list에 이동 방향을 담습니다.
세대가 넘어가면
이전 세대 이동 방향 리스트의 뒤에서부터 요소를 빼서 +1하고
그 값을 이전 세대 이동 방향 리스트에 추가합니다.

입력 받은 세대 gen에 도달하였다면
이동 방향을 따라가며 map에 드래곤커브를 표시합니다.

네 꼭짓점이 드래곤 커브에 해당하는 칸은
map[i][j], map[i+1][j], map[i][j+1], map[i+1][j+1]의 값이
모두 1인 경우를 카운트하면 됩니다.

저도 삼전 문제를 몇개 풀어보고 있는데
회전을 정말 좋아하는 것 같습니다.
그런데 정말 다양한 회전을 구현해야해서 힘드네요;

수고하셨습니다.

Details

import java.io.*;
import java.util.*;

public class Main {
    static int N;
    static int[][] map = new int[101][101];
    static int[] dx = {1, 0, -1, 0};
    static int[] dy = {0, -1, 0, 1};

    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());

        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());

            int x = Integer.parseInt(st.nextToken());
            int y = Integer.parseInt(st.nextToken());
            int d = Integer.parseInt(st.nextToken());
            int gen = Integer.parseInt(st.nextToken());
            dragonCurve(x, y, d, gen);
        }
        System.out.print(checkBox());
    }
    static void dragonCurve(int x, int y, int d, int gen) {
        List<Integer> path = new ArrayList<>();
        path.add(d);

        int count = 0;
        while (count < gen) {

            for (int i = path.size()-1; i >= 0; i--) {
                path.add((path.get(i)+1) % 4);
            }

            count++;
        }

        map[y][x] = 1;
        for (int i : path) {
            x += dx[i];
            y += dy[i];
            map[y][x] = 1;
        }
    }

    static int checkBox() {
        int response = 0;

        for (int i = 0; i < 100; i++) {
            for (int j = 0; j < 100; j++) {
                if (map[i][j] == 1 && map[i+1][j] == 1 && map[i][j+1] == 1 && map[i+1][j+1] == 1) {
                    response++;
                }
            }
        }

        return response;
    }
}

[kangrae-jo]

준 드레곤의 드레곤 커브 문제