n = int(input())
grid = [list(map(int, input().split())) for _ in range(n)] 



def get_coin(i, j):
    i_s, i_e = i, i + 2
    j_s, j_e = j, j + 2
    
    coin = 0

    for i in range(i_s, i_e + 1):
        for j in range(j_s, j_e + 1):
            coin += grid[i][j]
    return coin

max_coin = 0
for i in range(n):
    for j in range(n):

        if i + 2 >= n or j + 2 >= n:
            continue
        
        coin = get_coin(i, j)
        max_coin = max(max_coin, coin)

print(max_coin)

'알고리즘 > CodeTree' 카테고리의 다른 글

[코드트리] 왕실의 기사 대결 | 삼성 SW 역량테스트 2023 하반기 오전 1번 문제  (0) 2024.04.13
[코드트리] 포탑 부수기 | 삼성 SW 역량테스트 2023 상반기 오전 1번 문제  (0) 2024.04.10
[코드트리] 메이즈러너 | 삼성 SW 역량테스트 2023 상반기 오후 1번 문제  (0) 2024.04.10
[코드트리] 코드트리빵 | 삼성 SW 역량테스트 2022 하반기 오후 1번 문제  (0) 2024.04.10
[CodeTree] 트로미노 | 완전탐색  (0) 2024.03.30

ref : 코드트리 왕실의 기사 해설 / https://hyundoil.tistory.com/215 

왕실의 기사 대결

왕실의 기사들은  크기의 체스판 위에서 대결을 준비하고 있습니다. 체스판의 왼쪽 상단은 (1,1)로 시작하며, 각 칸은 빈칸, 함정, 또는 벽으로 구성되어 있습니다. 체스판 밖도 벽으로 간주합니다.

왕실의 기사들은 자신의 마력으로 상대방을 밀쳐낼 수 있습니다. 각 기사의 초기위치는 로 주어지며, 그들은 방패를 들고 있기 때문에 를 좌측 상단으로 하며  크기의 직사각형 형태를 띄고 있습니다. 각 기사의 체력은 로 주어집니다.

 

(1) 기사 이동

왕에게 명령을 받은 기사는 상하좌우 중 하나로 한 칸 이동할 수 있습니다. 이때 만약 이동하려는 위치에 다른 기사가 있다면 그 기사도 함께 연쇄적으로 한 칸 밀려나게 됩니다. 그 옆에 또 기사가 있다면 연쇄적으로 한 칸씩 밀리게 됩니다. 하지만 만약 기사가 이동하려는 방향의 끝에 벽이 있다면 모든 기사는 이동할 수 없게 됩니다. 또, 체스판에서 사라진 기사에게 명령을 내리면 아무런 반응이 없게 됩니다.

 

(2) 대결 대미지

명령을 받은 기사가 다른 기사를 밀치게 되면, 밀려난 기사들은 피해를 입게 됩니다. 이때 각 기사들은 해당 기사가 이동한 곳에서  직사각형 내에 놓여 있는 함정의 수만큼만 피해를 입게 됩니다. 각 기사마다 피해를 받은 만큼 체력이 깎이게 되며, 현재 체력 이상의 대미지를 받을 경우 기사는 체스판에서 사라지게 됩니다. 단, 명령을 받은 기사는 피해를 입지 않으며, 기사들은 모두 밀린 이후에 대미지를 입게 됩니다. 밀렸더라도 밀쳐진 위치에 함정이 전혀 없다면 그 기사는 피해를 전혀 입지 않게 됨에 유의합니다.

 번에 걸쳐 왕의 명령이 주어졌을 때,  번의 대결이 모두 끝난 후 생존한 기사들이 총 받은 대미지의 합을 출력하는 프로그램을 작성해보세요.

직관

  • 해당 문제는 기사들이 체스판 위에서 주어진 명령에 따라 이동하며 상호작용하는 과정을 시뮬레이션함
    • 기사들이 이동하면서 다른 기사들을 밀쳐내고
    • 밀려난 기사가 함정에 빠져 데미지를 입게되는 복잡한 상황 처리
  • 이 문제를 해결하기 위해
    • 각 기사의 특성(위치, 크기, 체력)
    • 체스판의 상태(빈칸, 함정, 벽)를 효율적으로 관리하고
  • 왕의 명령을 받은 후에 어떤 기사들이 어디로 이동하며 데미지를 입게 되는지 판단해야함
  • 이 과정에서는
    • 벽에 의해 이동이 불가한 상황
    • 다른 기사에 의해 연쇄적으로 밀려나는 경우 고려
  • 이러한 조건을 만족하면서 생존한 기사들이 받은 총 데미지 계산

알고리즘

  • 기사의 이동을 시뮬레이션 하기 위해 trymovement 함수 사용
    • 특정 기사가 방향에 움직일 수 있는지 여부를 확인
    • 이동할 수 있다면 
      • 해당 기사와 충돌하는 다른 기사들까지의 이동 가능성을 큐를 사용해 연쇄적으로 확인
        • 연쇄적 이동 과정에서는
          • 벽이나 체스판 경계를 넘는지 확인
          • 이동한 영역에 함정이 있는지에 따라 데미지 계산
          • 이때 함수 내부에서 각 기사가 이동한 결과를 임시적으로 저장하고
          • 최종적으로 이동 가능 여부를 판단한 뒤
          • 실제 기사의 위치와 체력 정보를 업데이트하는 movepiece 함수 호출
    • 이 과정을 Q 회 명령이 반복된 이후
    • 생존한 기사들의 데미지를 계산

Input

첫 번째 줄에 , , 가 공백을 사이에 두고 주어집니다.

다음  개의 줄에 걸쳐서  크기의 체스판에 대한 정보가 주어집니다.

  • 이라면 빈칸을 의미합니다.
  • 이라면 함정을 의미합니다.
  • 라면 벽을 의미합니다.

다음  개의 줄에 걸쳐서 초기 기사들의 정보가 주어집니다. 이 정보는  순으로 주어지며, 이는 기사의 처음 위치는 를 좌측 상단 꼭지점으로 하며 세로 길이가 , 가로 길이가 인 직사각형 형태를 띄고 있으며 초기 체력이 라는 것을 의미합니다. 입력은 1번 기사부터 번 기사까지 순서대로 정보가 주어집니다.

단, 처음 주어지는 기사들의 위치는 기사들끼리 서로 겹쳐져 있지 않습니다. 또한 기사와 벽은 겹쳐서 주어지지 않습니다.

다음  개의 줄에 걸쳐 왕의 명령에 대한 정보가 주어집니다. 이 정보는  형태로 주어지며 이는 번 기사에게 방향 로 한 칸 이동하라는 명령임을 뜻합니다. 는 1 이상  이하의 값을 갖으며, 이미 사라진 기사 번호가 주어질 수도 있음에 유의합니다. 는 0, 1, 2, 3 중에 하나이며 각각 위쪽, 오른쪽, 아래쪽, 왼쪽 방향을 의미합니다.

  • : 체스판의 크기 ()
  • : 기사의 수 ()
  • : 명령의 수 ()
  • : 기사의 체력 ()

 

from collections import deque 

def in_range(nx, ny, h, w):
    return 1 <= nx <= L + 1 - h and 1 <= ny <= L + 1 - w

def trymovement(idx, dir):
    # q 선언 및 초기화
    q = deque()
    q.append(idx)

    # dmg, is_move, nr, nc 초기화
    for i in range(1, N + 1):
        dmg[i] = 0
        is_move[i] = False
        nr[i] = r[i]
        nc[i] = c[i]

    # 현재 idx번째 기사 기준으로 움직임 시작
    is_move[idx] = True

    # 현재 기사를 시작으로 연쇄작용 일어나는 기사들 q에 append
    while q:
        # 현재 idx 부터 시작
        x = q.popleft()
        nr[x] += direct[dir][0]
        nc[x] += direct[dir][1]

        # 범위 넘어가면 패스
        if not in_range(nr[x], nc[x], h[x], w[x]):
            return False
        # 대상 기사가 함정이나 벽에 충돌하는지 확인
        for i in range(nr[x], nr[x] + h[x]):
            for j in range(nc[x], nc[x] + w[x]):
                # 함정에 충돌하면 데미지 추가
                if board[i][j] == 1:
                    dmg[x] += 1
                # 벽에 충돌하면 패스
                if board[i][j] == 2:
                    return False

        # 대상 기사가 다른 기사랑 충돌할 경우 충돌된 기사도 움직임
        for i in range(1, N + 1):
            # 이미 움직였거나 체력이 0 이하라 체스판에 없는 경우 패스
            if is_move[i] or k[i] <= 0:
                continue
            # 체스판의 범위를 벗어나면 패스
            # 1. i번째 기사 위치가 현재 기사의 새 위치 범위 밖에 있거나
            # 2. 현재 기사의 새 위치가 i번째 기사 범위 밖이면 패스
            if r[i] > nr[x] + h[x] - 1 or nr[x] > r[i] + h[i] - 1:
                continue
            if c[i] > nc[x] + w[x] - 1 or nc[x] > c[i] + w[i] - 1:
                continue

            # 충돌된 기사 이동 체크
            is_move[i] = True
            # 연쇄작용을 위해 q에 append
            q.append(i)

    # False 없이 도달했으면 해당 기사 데미지 0 후 True 리턴
    dmg[idx] = 0
    return True

def move_piece(idx, dir):
    # 체력이 0 이하라 체스판에 없는 경우 패스
    if k[idx] <= 0:
        return
    # idx 번째 기사가 움직일 수 있는지 확인
    if trymovement(idx, dir):
        # 움직일 수 있으면 기사들의 위치와 체력 업데이트
        for i in range(1, N + 1):
            r[i] = nr[i]
            c[i] = nc[i]
            k[i] -= dmg[i]

# 메인 함수
if __name__ == "__main__" :
    L, N, Q = map(int, input().split())
    MAX_L = 31
    MAX_N = 41

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

    board = [[2] * (L + 2)] \
            + [[2] + list(map(int, input().split())) + [2] for _ in range(L)] \
            + [[2] * (L + 2)]

    init_k = [0] * MAX_N
    r = [0] * MAX_N
    c = [0] * MAX_N
    h = [0] * MAX_N
    w = [0] * MAX_N
    k = [0] * MAX_N
    nr = [0] * MAX_N
    nc = [0] * MAX_N
    dmg = [0] * MAX_N
    is_move = [False] * MAX_N

    for i in range(1, N + 1):
        r[i], c[i], h[i], w[i], k[i] = map(int, input().split())
        init_k[i] = k[i]

    for _ in range(Q):
        idx, d = map(int, input().split())
        move_piece(idx, d)

    ans = sum([init_k[i] - k[i] for i in range(1, N + 1) if k[i] > 0])
    print(ans)

'알고리즘 > CodeTree' 카테고리의 다른 글

[코드트리] 최고의 33위치  (0) 2024.07.04
[코드트리] 포탑 부수기 | 삼성 SW 역량테스트 2023 상반기 오전 1번 문제  (0) 2024.04.10
[코드트리] 메이즈러너 | 삼성 SW 역량테스트 2023 상반기 오후 1번 문제  (0) 2024.04.10
[코드트리] 코드트리빵 | 삼성 SW 역량테스트 2022 하반기 오후 1번 문제  (0) 2024.04.10
[CodeTree] 트로미노 | 완전탐색  (0) 2024.03.30

2. 공격자의 공격

위에서 선정된 공격자는 자신을 제외한 가장 강한 포탑을 공격합니다.
가장 강한 포탑은 위에서 정한 가장 약한 포탑 선정 기준의 반대이며, 다음과 같습니다.

  1. 공격력이 가장 높은 포탑이 가장 강한 포탑입니다.
  2. 만약 공격력이 가장 높은 포탑이 2개 이상이라면, 공격한지 가장 오래된 포탑이 가장 강한 포탑입니다. (모든 포탑은 시점 에 모두 공격한 경험이 있다고 가정하겠습니다.)
  3. 만약 그러한 포탑이 2개 이상이라면, 각 포탑 위치의 행과 열의 합이 가장 작은 포탑이 가장 강한 포탑입니다.
  4. 만약 그러한 포탑이 2개 이상이라면, 각 포탑 위치의 열 값이 가장 작은 포탑이 가장 강한 포탑입니다.

2.2 조건이 엄청 헷갈렸다.  

스터디하면서 해당 부분이 공격자가 공격한 시점을 요구하는 것을 깨달았다. (*고칠점 : 멋대로 해석해서 코드를 작성하지 말자) 

나는 공격 당한지 오래된 포탑인줄.. 이것도 문제를 제대로 안읽어서 발생한 문제다. 

같은 실수를 반복하지 말자. 

 

[잘못 짠 코드 - test case 3]

조건에 만족하지 않는 타겟으로 설정되는 오류가 발생했다. 

3번째 라인의 공격 시간을 체크하는 `is_attack` 배열의 초기값이 문제였다. 

time을 1로 초기화 하거나 그렇지 않으면 `is_attak` 자체를 0이 아닌 다른 값으로 초기화해주어야한다. 

n, m, k = map(int, input().split())
powers = [list(map(int, input().split())) for _ in range(n)]
is_attack = [[0] * m for _ in range(n)]
dxs, dys = [0, 1, 0, -1, 1, 1, -1, -1], [1, 0, -1, 0, -1, 1, -1, 1]
print(dxs[:4])
time = 0

for turn in range(k):
    attack = [[False] * m for _ in range(n)]
    print("턴시작")
    print("공격시간", is_attack)
    print_board()
    # 1. 공격자 설정
    attacker_x, attacker_y = attaker_setting()
    powers[attacker_x][attacker_y] += (n + m)
    print("공격력셋팅")
    print_board()
    point = powers[attacker_x][attacker_y]
    half_point = point // 2

    attack[attacker_x][attacker_y] = True
    is_attack[attacker_x][attacker_y] = time
    time += 1

 

[잘못 짠 코드 - test case 5] 

공격자 함수 범위를 잘못 구현했다. 

`if min_p < powers[x][y]:` -> `if min_p > powers[x][y]` 

def attaker_setting():
    min_p = 1000
    a_x, a_y = 0, 0  # 공격자 좌표

    for x in range(n):
        for y in range(m):
            if powers[x][y] == 0:
                continue 
            if min_p > powers[x][y]:
                min_p = powers[x][y]
                a_x, a_y = x, y 
            elif min_p == powers[x][y]: 
                if is_attack[x][y] > is_attack[a_x][a_y]:
                    a_x, a_y = x, y  # 현재 좌표로 갱신 
                elif is_attack[x][y] == is_attack[a_x][a_y]:  
                    if x + y > a_x + a_y:
                        a_x, a_y = x, y 
                    elif x + y == a_x + a_y: 
                        if y > a_y:
                            a_y = y
    return a_x, a_y

 

[잘못 짠 코드 - test case 6]

산 넘어 산...

+++

와 거의 2시간 만에 찾았다; 

 

                    elif x + y == t_x + t_y:
                        if y < t_y:
                            t_x, t_y = x, y

 

여기서 elif 안에 있는 if 문에 `t_y`를 넣어야하는데 `t_x`를 넣어서 틀린 거였다 ㅠㅠ

1. 변수 자동 완성을 믿지 말자.. 

2. 똑바로 보자.. 

3. 변수명을 더 가독성 있게 정의하자 ㅠㅠ

 

def target_setting(attacker_x, attacker_y):
    max_p = -1
    t_x, t_y = 0, 0  # 대상 좌표

    for x in range(n):
        for y in range(m): 
            if powers[x][y] == 0:   
                continue
            if x == attacker_x and y == attacker_y:  
                continue
            if max_p < powers[x][y]: 
                max_p = powers[x][y]
                t_x, t_y = x, y 
            elif max_p == powers[x][y]: 
                if is_attack[x][y] < is_attack[t_x][t_y]: 
                    t_x, t_y = x, y  
                elif is_attack[x][y] == is_attack[t_x][t_y]:
                    if x + y < t_x + t_y:
                        t_x, t_y = x, y
                    elif x + y == t_x + t_y:
                        if y < t_y:
                            t_x, t_y = x, y
    return t_x, t_y

 

됐다 !!!!!!!!!!!!

[최종코드] 

from collections import deque


def print_board():
    global powers
    for i in range(n):
        print(powers[i])
    print('----')


def attaker_setting():
    min_p =  10000
    a_x, a_y = 0, 0  # 공격자 좌표

    for x in range(n):
        for y in range(m):
            if powers[x][y] == 0:
                continue
            # 1. 공격력 가장 낮은 포탑 선정
            if min_p > powers[x][y]:
                min_p = powers[x][y]
                a_x, a_y = x, y
            # 1-1. 공격력이 가장 낮은 포탑이 2개 이상이면
            elif min_p == powers[x][y]: 
                # 1-1-1. 가장 최근에 공격한 포탑 (모든 포탑은 시점 0에 모두 공격한 경험이 있다고 가정)
                if is_attack[x][y] > is_attack[a_x][a_y]:
                    a_x, a_y = x, y  # 현재 좌표로 갱신
                # 1-2. 최근 공격한 포탑이 2개 이상이면
                elif is_attack[x][y] == is_attack[a_x][a_y]: 
                    if x + y > a_x + a_y:
                        a_x, a_y = x, y
                    # 1-3. 포탑 위치의 행과 열의 합이 같은게 2개 이상이면
                    elif x + y == a_x + a_y: 
                        # 1-3-1. 열이 가장 큰 포탑
                        if y > a_y:
                            a_y = y
    return a_x, a_y


def target_setting(attacker_x, attacker_y):
    max_p = -10000
    t_x, t_y = 0, 0  # 대상 좌표

    for x in range(n):
        for y in range(m):
            # 1. 공격력 가장 높은 포탑 선정
            if powers[x][y] == 0:  # 부서진 포탑 제외
                continue
            if x == attacker_x and y == attacker_y:  # 공격자 제외
                continue
            if max_p < powers[x][y]:
                max_p = powers[x][y]
                t_x, t_y = x, y
            # 1-1. 공격력이 가장 높은 포탑이 2개 이상이면
            elif max_p == powers[x][y]: 
                if is_attack[x][y] < is_attack[t_x][t_y]: 
                    t_x, t_y = x, y  # 현재 좌표로 갱신
                # 1-2. 최근 공격한 포탑이 2개 이상이면
                elif is_attack[x][y] == is_attack[t_x][t_y]:
                    # 1-2-1. 포탑 위치의 행과 열의 합이 가장 큰 포탑
                    if x + y < t_x + t_y:
                        t_x, t_y = x, y
                    # 1-3. 포탑 위치의 행과 열의 합이 같은게 2개 이상이면
                    elif x + y == t_x + t_y:
                        # 1-3-1. 열이 가장 큰 포탑
                        if y < t_y:
                            t_x, t_y = x, y
    return t_x, t_y


def laser(attacker_x, attacker_y, target_x, target_y): 
    visited = [[False] * m for _ in range(n)]

    q = deque()
    q.append((attacker_x, attacker_y, []))
    visited[attacker_x][attacker_y] = True

    while q:
        x, y, route = q.popleft()
        # 1-1. 상하좌우(우하좌상) 4개 방향 움직임
        for dx, dy in zip(dxs[:4], dys[:4]):
            # 1-3. 가장자리 범위 넘어서면 반대편으로 이동
            nx, ny = (x + dx) % n, (y + dy) % m
            if visited[nx][ny]:  # 방문 했으면 패스
                continue
            # 1-2. 부서진 포탑이 있는 위치는 지날 수 없음 (포탑의 공격력이 0인 곳)
            if powers[nx][ny] == 0:
                continue
            # 1-4. 최단 경로가 정해졌으면 공격 대상은 공격자의 공격력 만큼 피해
            if nx == target_x and ny == target_y:
                powers[target_x][target_y] -= point
                # 1-5. 공격 대상을 제외한 레이저 경로에 있는 포탑도 공격자 공격력의 절반 만큼 (공격력 2로 나눈 몫)
                for r_x, r_y in route:
                    powers[r_x][r_y] -= half_point
                    attack[r_x][r_y] = True
                return True
            # 경로 체크
            temp_route = route[:]
            temp_route.append((nx, ny))
            visited[nx][ny] = True
            q.append((nx, ny, temp_route)) 
    return False


def shell(attack_x, attack_y, target_x, target_y):
    powers[target_x][target_y] -= point

    for dx, dy in zip(dxs, dys):
        nx, ny = (target_x + dx) % n, (target_y + dy) % m

        if nx == attack_x and ny == attack_y:
            continue
        powers[nx][ny] -= half_point
        attack[nx][ny] = True


def break_check():
    for x in range(n):
        for y in range(m):
            if powers[x][y] < 0:
                powers[x][y] = 0


def max_check():
    return max([max(p) for p in powers])


def turrent_check():
    turrent = []
    turrent_cnt = 0

    for x in range(n):
        for y in range(m):
            if powers[x][y] == 0:
                continue
            turrent_cnt += 1

            if attack[x][y]:
                continue

            turrent.append((x, y))
    if turrent_cnt == 1:
        print(max_check())
        exit(0)
    for x, y in turrent:
        powers[x][y] += 1


n, m, k = map(int, input().split())
powers = [list(map(int, input().split())) for _ in range(n)]
is_attack = [[-1] * m for _ in range(n)]
dxs, dys = [0, 1, 0, -1, 1, 1, -1, -1], [1, 0, -1, 0, -1, 1, -1, 1]
 
time = 0

for turn in range(k):
    attack = [[False] * m for _ in range(n)]
   # 1. 공격자 설정
    attacker_x, attacker_y = attaker_setting()
    powers[attacker_x][attacker_y] += (n + m)
  
    point = powers[attacker_x][attacker_y]
    half_point = point // 2

    attack[attacker_x][attacker_y] = True
    is_attack[attacker_x][attacker_y] = time
    time += 1

    # 2. 공격자 공격
    target_x, target_y = target_setting(attacker_x, attacker_y)
    attack[target_x][target_y] = True 
    if not laser(attacker_x, attacker_y, target_x, target_y):
        shell(attacker_x, attacker_y, target_x, target_y) 
    break_check() 
    turrent_check() 

print(max_check())

https://www.codetree.ai/training-field/frequent-problems/problems/destroy-the-turret

'알고리즘 > CodeTree' 카테고리의 다른 글

[코드트리] 최고의 33위치  (0) 2024.07.04
[코드트리] 왕실의 기사 대결 | 삼성 SW 역량테스트 2023 하반기 오전 1번 문제  (0) 2024.04.13
[코드트리] 메이즈러너 | 삼성 SW 역량테스트 2023 상반기 오후 1번 문제  (0) 2024.04.10
[코드트리] 코드트리빵 | 삼성 SW 역량테스트 2022 하반기 오후 1번 문제  (0) 2024.04.10
[CodeTree] 트로미노 | 완전탐색  (0) 2024.03.30

 

N, M, K = map(int, input().split())
arr = [list(map(int, input().split())) for _ in range(N)]

for _ in range(M): # 사람 : -1로 표시
    i, j = map(lambda x: int(x) - 1, input().split())
    arr[i][j] -= 1

# 비상구 -46으로 표시
ei, ej = map(lambda x: int(x) - 1, input().split())
arr[ei][ej] = -46

ans = 0 # 이동거리 합
cnt = M

def find_square(arr):
    # [1 - 비상구와 모든 사람간의 가장 짧은 가로 또는 세로 거리 구하기]
    min_dist = N
    for i in range(N):
        for j in range(N):
            if -46 < arr[i][j] < 0: # 사람인 경우
                min_dist = min(min_dist, max(abs(ei - i), abs(ej -j))) # 가로,세로 (비상구 - 각 가로 세로)

    # [2 - (0, 0) 부터 순회하면서 길이 L인 정사각형에 비상구와 사람 있는지 체크 후 리턴 (return -> L + 1)]
    for si in range(N - min_dist):
        for sj in range(N - min_dist): # 가능한 모든 시작 위치
            if si <= ei <= (si + min_dist) and sj <= ej <= (sj + min_dist):
                # 비상구가 포함된 사각형이면
                for i in range(si, si + min_dist + 1):
                    for j in range(sj, sj + min_dist + 1):
                        # 그 사각형 순회
                        if -46 < arr[i][j] < 0: # 사람이면
                            return si, sj, (min_dist + 1)

def find_exit(arr):
    for i in range(N):
        for j in range(N):
            if arr[i][j] == -46:
                return i, j

for _ in range(K):
    # [1 - 모든 참가자 (동시에) 한 칸 이동(출구 최단거리 방향 상/하 우선)]
    # 출구 도착시 즉시 탈출
    new_a = [x[:] for x in arr]

    for i in range(N):
        for j in range(N):
            if -46 < arr[i][j] < 0: # 사람인 경우
                dist = abs(ei - i) + abs(ej - j) # 현재 비상구 까지의 거리
                # 네 방향 (상하 우선), 범위 내, 벽이 아니고 <= 0, 거리가 dist 보다 작으면
                # 빈칸이거나, 0, 다른 사람이 있거나, 비상구 거나
                for di, dj in ((-1, 0), (1, 0), (0, -1), (0, 1)): # 행렬 이동
                    ni, nj = i + di, j + dj # 상하좌우 탐색
                    if (0 <= ni < N) and (0 <= nj < N) and (arr[ni][nj] <= 0) and (dist > (abs(ei - ni) + abs(ej - nj))):
                        # 격자 범위 벗어나지 않고(유효한 범위) / 사람이고 / 현재 비상구 까지 거리 보다 작으면
                        ans += arr[i][j] # 이동 거리의 합 (현재 인원 수가 이동하는 것)
                        new_a[i][j] -= arr[i][j] # 이동 처리 다른 것과 혼동되지 않게 0이 아닌 다른 숫자로

                        if arr[ni][nj] == -46: # 비상구라면
                            cnt += arr[i][j] # 탈출
                        else: # 빈칸 또는 사람있는 자리
                            new_a[ni][nj] += arr[i][j] # 들어온 인원 추가
                        break

    arr = new_a
    if cnt == 0:
        break

    # [2 - 미로회전 (출구와 한 명 이상 참가자를 포함하는 가장 작은 정사각형)]
    # 시계방향 90도 : 같은 크기 -> 좌상단 행렬, 내구도 -1
    si, sj, L = find_square(arr) # 비상구 + 사람 포함 최소 정사각형

    new_a = [x[:] for x in arr]

    for i in range(L):
        for j in range(L):
            new_a[si + i][sj + j] = arr[si + L - 1 - j][sj + i]

            if new_a[si + i][sj + j] > 0: # 벽이면 회전시 1 감소 / 내구도가 0 이상이면 (벽이 존재 하면)
                new_a[si + i][sj + j] -= 1 # 내구도 처리

    arr = new_a
    # 회전 후 비상구 위치 저장
    ei, ej = find_exit(arr)


print(-ans)
print(ei + 1, ej + 1)

 

https://www.codetree.ai/training-field/frequent-problems/problems/maze-runner/description?page=1&pageSize=20

'알고리즘 > CodeTree' 카테고리의 다른 글

[코드트리] 왕실의 기사 대결 | 삼성 SW 역량테스트 2023 하반기 오전 1번 문제  (0) 2024.04.13
[코드트리] 포탑 부수기 | 삼성 SW 역량테스트 2023 상반기 오전 1번 문제  (0) 2024.04.10
[코드트리] 코드트리빵 | 삼성 SW 역량테스트 2022 하반기 오후 1번 문제  (0) 2024.04.10
[CodeTree] 트로미노 | 완전탐색  (0) 2024.03.30
[CodeTree] 행복한 수열의 개수 | 완전탐색  (0) 2024.03.30

0411 +++++

다시 풀었다.

Import & Input

import sys
from collections import deque

N, M = map(int, input().split())
grid = [
    list(map(lambda x: int(x) - 1, input().split()))
    for _ in range(N)
]
stores = [
    tuple(map(lambda x: int(x) - 1, input().split()))
    for _ in range(M)
]

INT_MAX = sys.maxsize
EMPTY = (-1, -1) # 초기값은 격자 밖
people = [EMPTY] * M
time = 0

direct = [(-1, 0), (0, -1), (0, 1), (1, 0)]
dist = [
    [0] * N
    for _ in range(N)
]
visited = [
    [False] * N
    for _ in range(N)
]

 

  1. 최단거리 문제이기 때문에 BFS를 사용한다. 따라서 deque를 import 해준다. 
  2. gird, stores : gird, stores 로 배열과 편의점 정보를 저장해준다. 이때, stores의 경우 lambda 함수를 사용해서 처음부터 -1을 하여 편의점의 좌표값을 격자의 범위에 맞게 입력 받는다. 
  3. INT_MAX : 각 편의점, 베이스 캠프의  여러 경로 중 최단경로를 찾아야하기 때문에 MAX 값 초기화
  4. EMPTY : 경로 밖에 있는 사람들의 좌표 초기값 (tuple)
  5. people : 사람들 좌표 - 1 x M (tuple)
  6. time : 분(mins) 정보
  7. direct : 우선순위 순서의 방향좌표 (상 좌 우 하)
  8. dist : 최단거리 저장할 리스트 - N x N
  9. visited : 방문확인용 리스트 - N x N

메인 코드

while True:
	time += 1
    simulate()
    if end():
    	break
print(time)

 

  1. while문을 활용해서 조건을 만족할 때 까지 반복
  2. simulate - 구현
  3. 종료 조건 만족하면 while문 탈출
  4. 최종 시간 출력

시뮬레이션

def simulate():
    for i in range(M):
        if people[i] == EMPTY or people[i] == stores[i]:
            continue
        bfs(stores[i])

        px, py = people[i]
        min_dist = INT_MAX
        min_x, min_y = -1, -1
        for d in range(4):
            dx, dy = direct[d]
            nx, ny = px + dx, py + dy
            if in_range(nx, ny) and visited[nx][ny] and min_dist > dist[nx][ny]:
                min_dist = dist[nx][ny]
                min_x, min_y = nx, ny
        people[i] = (min_x, min_y)

    for i in range(M):
        if people[i] == stores[i]:
            px, py = people[i]
            grid[px][py] = 2

    if time > M:
        return

    bfs(stores[time - 1])
    min_dist = INT_MAX
    min_x, min_y = -1, -1
    for i in range(N):
        for j in range(N):
            if visited[i][j] and grid[i][j] == 1 and min_dist > dist[i][j]:
                min_dist = dist[i][j]
                min_x, min_y = i, j

    people[time - 1] = (min_x, min_y)
    grid[min_x][min_y] = 2

 

  1. 문제에서 주어진 순서대로 구현 

BFS 

def bfs(start_pos):
    for i in range(N):
        for j in range(N):
            visited[i][j] = False
            dist[i][j] = 0

    q = deque()
    q.append(start_pos)
    sx, sy = start_pos
    visited[sx][sy] = True
    dist[sx][sy] = 0

    while q:
        x, y = q.popleft()
        for i in range(4):
            dx, dy = direct[i]
            nx, ny = x + dx, y + dy

            if in_range(nx, ny) and not visited[nx][ny] and grid[nx][ny] != 2:
                visited[nx][ny] = True 
                dist[nx][ny] = dist[x][y] + 1 
                q.append((nx, ny))
  1. 베이스 캠프로 갈 때, 가까운 편의점을 고를 때 모두 사용되기 때문에 함수 호출시 초기화
  2. 거리를 체크해야하기 때문에 dist[x][y]  + 1 

종료

def end():
    for i in range(M):
        if people[i] != stores[i]:
            return False
    return True

 

[전체 코드]

더보기

전체 코드

 

import sys
from collections import deque

N, M = map(int, input().split())
grid = [
    list(map(lambda x: int(x) - 1, input().split()))
    for _ in range(N)
]
stores = [
    tuple(map(lambda x: int(x) - 1, input().split()))
    for _ in range(M)
]

INT_MAX = sys.maxsize
EMPTY = (-1, -1) # 초기값은 격자 밖
people = [EMPTY] * M
time = 0

direct = [(-1, 0), (0, -1), (0, 1), (1, 0)]
dist = [
    [0] * N
    for _ in range(N)
]
visited = [
    [False] * N
    for _ in range(N)
]

def in_range(x, y):
    return 0 <= x < N and 0 <= y < N

def bfs(start_pos):
    for i in range(N):
        for j in range(N):
            visited[i][j] = False
            dist[i][j] = 0

    q = deque()
    q.append(start_pos)
    sx, sy = start_pos
    visited[sx][sy] = True
    dist[sx][sy] = 0

    while q:
        x, y = q.popleft()
        for i in range(4):
            dx, dy = direct[i]
            nx, ny = x + dx, y + dy

            if in_range(nx, ny) and not visited[nx][ny] and grid[nx][ny] != 2:
                visited[nx][ny] = True
                dist[nx][ny] = dist[x][y] + 1
                q.append((nx, ny))

def simulate():
    for i in range(M):
        if people[i] == EMPTY or people[i] == stores[i]:
            continue

        bfs(stores[i])

        px, py = people[i]

        min_dist = INT_MAX
        min_x, min_y = -1, -1

        for i in range(4):
            dx, dy = direct[i]
            nx, ny = px + dx, py + dy
            if in_range(nx, ny) and visited[nx][ny] and min_dist > dist[nx][ny]:
                min_dist = dist[nx][ny]
                min_x, min_y = nx, ny
        people[i] = (min_x, min_y)

    for i in range(M):
        if people[i] == stores[i]:
            px, py = people[i]
            grid[px][py] = 2

    if time > M:
        return

    bfs(stores[time - 1])
    min_dist = INT_MAX
    min_x, min_y = -1, -1
    for i in range(N):
        for j in range(N):
            if visited[i][j] and grid[i][j] == 1 and min_dist > dist[i][j]:
                min_dist = dist[i][j]
                min_x, min_y = i, j

    people[time - 1] = (min_x, min_y)
    grid[min_x][min_y] = 2

def end():
    for i in range(M):
        if people[i] != stores[i]:
            return False
    return True

while True:
    time += 1
    simulate()
    if end():
        break

print(time)

 

 

잘못 짠 코드

store = [list(map(lambda x: int(x) - 1, input().split())) for _ in range(m)]

 

 

습관적으로 list 형태로 편의점 정보를 저장했다.

그래서 시뮬레이션 돌릴 때 people과 store에 형태가 맞지 않아 무한루프에 빠졌었다. 

 

주의점

1. 생각하고 코드짜기

2. 파이참 디버깅 연습

3. 디렉션 리스트 작성 시 x, y 축이 아닌 행렬로 생각하기 (헷갈리지말자) 

 

 

import sys
from collections import deque

def print_arr(arr):
    for i in arr:
        print(i, end = '\n')
    print("---------")

def in_range(r, c):
    return 0 <= r < n and 0 <= c < n

def can_go(r, c):
    return in_range(r, c) and not visited[r][c] and grid[r][c] != -100 

n, m = map(int, input().split())
grid = [list(map(int, input().split())) for _ in range(n)]
store = [tuple(map(lambda x: int(x) - 1, input().split())) for _ in range(m)]

EMPTY = (-1, -1)
INI_MAX = sys.maxsize

people = [EMPTY] * m
time = 0

drs, dcs = [-1, 0, 0, 1], [0, -1, 1, 0]
visited = [[False] * n for _ in range(n)]
step = [[0] * n for _ in range(n)] # 최단거리 결과 기록
 
# start_pos를 시작으로
# 시작점으로 부터 최단거리 결과는 step 배열에 저장
def bfs(start_pos):
    # visited, step 값 초기화
    for i in range(n):
        for j in range(n):
            visited[i][j] = False
            step[i][j] = 0
    
    q = deque()
    q.append(start_pos)
    sx, sy = start_pos 
    visited[sx][sy] = True
    step[sx][sy] = 0

    while q:
        r, c = q.popleft()

        for dr, dc in zip(drs, dcs):
            nr, nc = r + dr, c + dc

            if can_go(nr, nc): 
                visited[nr][nc] = True
                step[nr][nc] = step[r][c] + 1
                q.append((nr, nc))

def simulation():
    # 1. 격자에 있는 사람들에 한하여 편의점 방향으로 1칸 움직임
    for i in range(m):
        # 격자 밖 or 편의점 도착
        if people[i] == EMPTY or people[i] == store[i]:
            continue
        bfs(store[i])

        pr, pc = people[i]
        
        min_dist = INI_MAX
        min_r, min_c = -1, -1 

        for dr, dc in zip(drs, dcs):
            nr, nc = pr + dr, pc + dc
            if in_range(nr, nc) and visited[nr][nc] and min_dist > step[nr][nc]:
                min_dist = step[nr][nc]
                min_r, min_c = nr, nc
        people[i] = (min_r, min_c)
    
    # 2. 편의점에 먼저 도착한 사람들에 한해서 앞으로 이동 불가 표시 -> grid : -100 
    for i in range(m):
        if people[i] == store[i]:
            pr, pc = people[i]
            grid[pr][pc] = -100
    
    # 3. 현재 시간 time에 대해 time <= m 을 만족하면 t가 베캠으로 이동
    # time이 m 보다 크면 패스
    if time > m:
        return
    
    # 3-1. 편점에서 가장 가까운 베캠 고르기 위해 
    # 편점을 시작으로 하는 bfs 
    bfs(store[time - 1])

    # 3-2. 편점에서 가장 가까운 베캠 선택
    min_dist = INI_MAX
    min_r, min_c = -1, -1
    for i in range(n):
        for j in range(n):
            if visited[i][j] and grid[i][j] == 1 and min_dist > step[i][j]:
                min_dist = step[i][j]
                min_r, min_c = i, j

    people[time - 1] = (min_r, min_c)
    grid[min_r][min_c] = - 100

def end():
    for i in range(m):
        if people[i] != store[i]:
            return False
    return True

while True:
    time += 1
    simulation()

    if end():
        break

print(time)

 https://www.codetree.ai/training-field/frequent-problems/problems/codetree-mon-bread/description?page=1&pageSize=20 

 

코드트리 | 코딩테스트 준비를 위한 알고리즘 정석

국가대표가 만든 코딩 공부의 가이드북 코딩 왕초보부터 꿈의 직장 코테 합격까지, 국가대표가 엄선한 커리큘럼으로 준비해보세요.

www.codetree.ai

 

 

'알고리즘 > CodeTree' 카테고리의 다른 글

[코드트리] 왕실의 기사 대결 | 삼성 SW 역량테스트 2023 하반기 오전 1번 문제  (0) 2024.04.13
[코드트리] 포탑 부수기 | 삼성 SW 역량테스트 2023 상반기 오전 1번 문제  (0) 2024.04.10
[코드트리] 메이즈러너 | 삼성 SW 역량테스트 2023 상반기 오후 1번 문제  (0) 2024.04.10
[CodeTree] 트로미노 | 완전탐색  (0) 2024.03.30
[CodeTree] 행복한 수열의 개수 | 완전탐색  (0) 2024.03.30

https://www.codetree.ai/missions/2/problems/tromino/description

 

n, m = tuple(map(int, input().split()))
grid = [list(map(int, input().split())) for _ in range(n)]
print(grid)

shapes = [
    [[1, 1, 0],
     [1, 0, 0],
     [0, 0, 0]],

    [[1, 1, 0],
     [0, 1, 0],
     [0, 0, 0]],

    [[1, 0, 0],
     [1, 1, 0],
     [0, 0, 0]],

    [[0, 1, 0],
     [1, 1, 0],
     [0, 0, 0]],

    [[1, 1, 1],
     [0, 0, 0],
     [0, 0, 0]],

    [[1, 0, 0],
     [1, 0, 0],
     [1, 0, 0]],
]


def get_max_sum(x, y):
    max_sum = 0

    for i in range(6):
        print(f"{i}번째 격자")
        is_possible = True
        sum_of_nums = 0

        for dx in range(0, 3):
            # dx : 0, 1, 2
            for dy in range(0, 3):
                # dy : 0, 1, 2
                print(f"shapes[{i}][{dx}][{dy}]", shapes[i][dx][dy])
                if shapes[i][dx][dy] == 0: # 도형 위치 확인
                    print("도형없음")
                    '''
                    shape[0]: 
                    [[1, 1, 0], 
                    [1, 0, 0],
                    [0, 0, 0]]
                    
                    dy: 0 / dy: 0 
                    >> [1]
                    '''
                    continue

                print("도형있음")
                if x + dx >= n or y + dy >= m: # 격자 벗어나는지 확인
                    """
                    x: grid[0]
                    dx: 0
                    
                    y: grid[0][0]
                    dy: 0 
                    
                    """
                    is_possible = False
                    print("불가능")
                else:
                    print("가능")
                    """
                    x + dx: 0
                    """
                    print(f"grid[{x} + {dx}][{y} + {dy}]", grid[x + dx][y + dy])
                    sum_of_nums += grid[x + dx][y + dy]

        if is_possible:
            max_sum = max(max_sum, sum_of_nums)
            print("합", max_sum)

    return max_sum


ans = 0

for i in range(n):
    for j in range(m):
        print(i, j)
        ans = max(ans, get_max_sum(i, j))

print(ans)

 

레전드로 어렵다

디버깅하면서 겨우 이해했

더보기

[입력]

3 3
1 2 3
3 2 1
3 1 1

grid >>
[1, 2, 3]
[3, 2, 1]
[3, 1, 1]
grid :  0 0


0번째 격자
shapes[0][0][0] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 0][0 + 0] :  1
shapes[0][0][1] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 0][0 + 1] :  2
shapes[0][0][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][1][0] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 1][0 + 0] :  3
shapes[0][1][1] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][1][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][0] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][1] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
합 6
1번째 격자
shapes[1][0][0] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 0][0 + 0] :  1
shapes[1][0][1] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 0][0 + 1] :  2
shapes[1][0][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][1][0] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][1][1] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 1][0 + 1] :  2
shapes[1][1][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][0] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][1] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
합 6
2번째 격자
shapes[2][0][0] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 0][0 + 0] :  1
shapes[2][0][1] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][0][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][1][0] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 1][0 + 0] :  3
shapes[2][1][1] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 1][0 + 1] :  2
shapes[2][1][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][0] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][1] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
합 6
3번째 격자
shapes[3][0][0] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][0][1] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 0][0 + 1] :  2
shapes[3][0][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][1][0] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 1][0 + 0] :  3
shapes[3][1][1] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 1][0 + 1] :  2
shapes[3][1][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][0] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][1] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
합 7
4번째 격자
shapes[4][0][0] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 0][0 + 0] :  1
shapes[4][0][1] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 0][0 + 1] :  2
shapes[4][0][2] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 0][0 + 2] :  3
shapes[4][1][0] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][1][1] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][1][2] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][0] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][1] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][2] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
합 7
5번째 격자
shapes[5][0][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
가능
grid[0 + 0][0 + 0] :  1
shapes[5][0][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][0][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][1][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
가능
grid[0 + 1][0 + 0] :  3
shapes[5][1][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][1][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][2][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
가능
grid[0 + 2][0 + 0] :  3
shapes[5][2][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][2][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
합 7
grid :  0 1
0번째 격자
shapes[0][0][0] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 0][1 + 0] :  2
shapes[0][0][1] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 0][1 + 1] :  3
shapes[0][0][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][1][0] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 1][1 + 0] :  2
shapes[0][1][1] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][1][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][0] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][1] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
합 7
1번째 격자
shapes[1][0][0] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 0][1 + 0] :  2
shapes[1][0][1] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 0][1 + 1] :  3
shapes[1][0][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][1][0] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][1][1] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 1][1 + 1] :  1
shapes[1][1][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][0] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][1] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
합 7
2번째 격자
shapes[2][0][0] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 0][1 + 0] :  2
shapes[2][0][1] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][0][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][1][0] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 1][1 + 0] :  2
shapes[2][1][1] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 1][1 + 1] :  1
shapes[2][1][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][0] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][1] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
합 7
3번째 격자
shapes[3][0][0] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][0][1] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 0][1 + 1] :  3
shapes[3][0][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][1][0] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 1][1 + 0] :  2
shapes[3][1][1] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 1][1 + 1] :  1
shapes[3][1][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][0] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][1] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
합 7
4번째 격자
shapes[4][0][0] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 0][1 + 0] :  2
shapes[4][0][1] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 0][1 + 1] :  3
shapes[4][0][2] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
불가능
shapes[4][1][0] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][1][1] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][1][2] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][0] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][1] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][2] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
5번째 격자
shapes[5][0][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
가능
grid[0 + 0][1 + 0] :  2
shapes[5][0][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][0][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][1][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
가능
grid[0 + 1][1 + 0] :  2
shapes[5][1][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][1][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][2][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
가능
grid[0 + 2][1 + 0] :  1
shapes[5][2][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][2][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
합 7
grid :  0 2
0번째 격자
shapes[0][0][0] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 0][2 + 0] :  3
shapes[0][0][1] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
불가능
shapes[0][0][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][1][0] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 1][2 + 0] :  1
shapes[0][1][1] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][1][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][0] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][1] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
1번째 격자
shapes[1][0][0] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 0][2 + 0] :  3
shapes[1][0][1] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[1][0][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][1][0] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][1][1] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[1][1][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][0] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][1] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
2번째 격자
shapes[2][0][0] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 0][2 + 0] :  3
shapes[2][0][1] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][0][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][1][0] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 1][2 + 0] :  1
shapes[2][1][1] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[2][1][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][0] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][1] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
3번째 격자
shapes[3][0][0] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][0][1] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[3][0][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][1][0] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 1][2 + 0] :  1
shapes[3][1][1] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[3][1][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][0] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][1] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
4번째 격자
shapes[4][0][0] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
가능
grid[0 + 0][2 + 0] :  3
shapes[4][0][1] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
불가능
shapes[4][0][2] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
불가능
shapes[4][1][0] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][1][1] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][1][2] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][0] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][1] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][2] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
5번째 격자
shapes[5][0][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
가능
grid[0 + 0][2 + 0] :  3
shapes[5][0][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][0][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][1][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
가능
grid[0 + 1][2 + 0] :  1
shapes[5][1][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][1][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][2][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
가능
grid[0 + 2][2 + 0] :  1
shapes[5][2][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][2][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
합 5
grid :  1 0
0번째 격자
shapes[0][0][0] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 0][0 + 0] :  3
shapes[0][0][1] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 0][0 + 1] :  2
shapes[0][0][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][1][0] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 1][0 + 0] :  3
shapes[0][1][1] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][1][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][0] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][1] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
합 8
1번째 격자
shapes[1][0][0] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 0][0 + 0] :  3
shapes[1][0][1] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 0][0 + 1] :  2
shapes[1][0][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][1][0] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][1][1] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 1][0 + 1] :  1
shapes[1][1][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][0] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][1] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
합 8
2번째 격자
shapes[2][0][0] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 0][0 + 0] :  3
shapes[2][0][1] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][0][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][1][0] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 1][0 + 0] :  3
shapes[2][1][1] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 1][0 + 1] :  1
shapes[2][1][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][0] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][1] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
합 8
3번째 격자
shapes[3][0][0] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][0][1] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 0][0 + 1] :  2
shapes[3][0][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][1][0] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 1][0 + 0] :  3
shapes[3][1][1] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 1][0 + 1] :  1
shapes[3][1][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][0] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][1] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
합 8
4번째 격자
shapes[4][0][0] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 0][0 + 0] :  3
shapes[4][0][1] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 0][0 + 1] :  2
shapes[4][0][2] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 0][0 + 2] :  1
shapes[4][1][0] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][1][1] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][1][2] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][0] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][1] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][2] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
합 8
5번째 격자
shapes[5][0][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
가능
grid[1 + 0][0 + 0] :  3
shapes[5][0][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][0][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][1][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
가능
grid[1 + 1][0 + 0] :  3
shapes[5][1][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][1][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][2][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
불가능
shapes[5][2][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][2][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
grid :  1 1
0번째 격자
shapes[0][0][0] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 0][1 + 0] :  2
shapes[0][0][1] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 0][1 + 1] :  1
shapes[0][0][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][1][0] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 1][1 + 0] :  1
shapes[0][1][1] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][1][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][0] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][1] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
합 4
1번째 격자
shapes[1][0][0] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 0][1 + 0] :  2
shapes[1][0][1] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 0][1 + 1] :  1
shapes[1][0][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][1][0] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][1][1] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 1][1 + 1] :  1
shapes[1][1][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][0] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][1] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
합 4
2번째 격자
shapes[2][0][0] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 0][1 + 0] :  2
shapes[2][0][1] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][0][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][1][0] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 1][1 + 0] :  1
shapes[2][1][1] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 1][1 + 1] :  1
shapes[2][1][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][0] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][1] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
합 4
3번째 격자
shapes[3][0][0] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][0][1] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 0][1 + 1] :  1
shapes[3][0][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][1][0] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 1][1 + 0] :  1
shapes[3][1][1] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 1][1 + 1] :  1
shapes[3][1][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][0] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][1] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
합 4
4번째 격자
shapes[4][0][0] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 0][1 + 0] :  2
shapes[4][0][1] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 0][1 + 1] :  1
shapes[4][0][2] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
불가능
shapes[4][1][0] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][1][1] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][1][2] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][0] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][1] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][2] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
5번째 격자
shapes[5][0][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
가능
grid[1 + 0][1 + 0] :  2
shapes[5][0][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][0][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][1][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
가능
grid[1 + 1][1 + 0] :  1
shapes[5][1][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][1][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][2][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
불가능
shapes[5][2][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][2][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
grid :  1 2
0번째 격자
shapes[0][0][0] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 0][2 + 0] :  1
shapes[0][0][1] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
불가능
shapes[0][0][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][1][0] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 1][2 + 0] :  1
shapes[0][1][1] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][1][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][0] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][1] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
1번째 격자
shapes[1][0][0] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 0][2 + 0] :  1
shapes[1][0][1] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[1][0][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][1][0] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][1][1] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[1][1][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][0] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][1] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
2번째 격자
shapes[2][0][0] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 0][2 + 0] :  1
shapes[2][0][1] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][0][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][1][0] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 1][2 + 0] :  1
shapes[2][1][1] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[2][1][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][0] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][1] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
3번째 격자
shapes[3][0][0] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][0][1] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[3][0][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][1][0] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 1][2 + 0] :  1
shapes[3][1][1] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[3][1][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][0] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][1] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
4번째 격자
shapes[4][0][0] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
가능
grid[1 + 0][2 + 0] :  1
shapes[4][0][1] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
불가능
shapes[4][0][2] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
불가능
shapes[4][1][0] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][1][1] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][1][2] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][0] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][1] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][2] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
5번째 격자
shapes[5][0][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
가능
grid[1 + 0][2 + 0] :  1
shapes[5][0][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][0][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][1][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
가능
grid[1 + 1][2 + 0] :  1
shapes[5][1][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][1][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][2][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
불가능
shapes[5][2][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][2][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
grid :  2 0
0번째 격자
shapes[0][0][0] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
가능
grid[2 + 0][0 + 0] :  3
shapes[0][0][1] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
가능
grid[2 + 0][0 + 1] :  1
shapes[0][0][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][1][0] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
불가능
shapes[0][1][1] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][1][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][0] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][1] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
1번째 격자
shapes[1][0][0] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
가능
grid[2 + 0][0 + 0] :  3
shapes[1][0][1] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
가능
grid[2 + 0][0 + 1] :  1
shapes[1][0][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][1][0] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][1][1] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[1][1][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][0] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][1] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
2번째 격자
shapes[2][0][0] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[2 + 0][0 + 0] :  3
shapes[2][0][1] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][0][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][1][0] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[2][1][1] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[2][1][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][0] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][1] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
3번째 격자
shapes[3][0][0] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][0][1] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[2 + 0][0 + 1] :  1
shapes[3][0][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][1][0] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[3][1][1] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[3][1][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][0] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][1] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
4번째 격자
shapes[4][0][0] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
가능
grid[2 + 0][0 + 0] :  3
shapes[4][0][1] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
가능
grid[2 + 0][0 + 1] :  1
shapes[4][0][2] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
가능
grid[2 + 0][0 + 2] :  1
shapes[4][1][0] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][1][1] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][1][2] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][0] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][1] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][2] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
합 5
5번째 격자
shapes[5][0][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
가능
grid[2 + 0][0 + 0] :  3
shapes[5][0][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][0][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][1][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
불가능
shapes[5][1][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][1][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][2][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
불가능
shapes[5][2][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][2][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
grid :  2 1
0번째 격자
shapes[0][0][0] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
가능
grid[2 + 0][1 + 0] :  1
shapes[0][0][1] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
가능
grid[2 + 0][1 + 1] :  1
shapes[0][0][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][1][0] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
불가능
shapes[0][1][1] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][1][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][0] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][1] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
1번째 격자
shapes[1][0][0] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
가능
grid[2 + 0][1 + 0] :  1
shapes[1][0][1] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
가능
grid[2 + 0][1 + 1] :  1
shapes[1][0][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][1][0] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][1][1] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[1][1][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][0] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][1] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
2번째 격자
shapes[2][0][0] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[2 + 0][1 + 0] :  1
shapes[2][0][1] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][0][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][1][0] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[2][1][1] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[2][1][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][0] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][1] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
3번째 격자
shapes[3][0][0] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][0][1] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[2 + 0][1 + 1] :  1
shapes[3][0][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][1][0] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[3][1][1] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[3][1][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][0] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][1] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
4번째 격자
shapes[4][0][0] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
가능
grid[2 + 0][1 + 0] :  1
shapes[4][0][1] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
가능
grid[2 + 0][1 + 1] :  1
shapes[4][0][2] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
불가능
shapes[4][1][0] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][1][1] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][1][2] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][0] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][1] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][2] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
5번째 격자
shapes[5][0][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
가능
grid[2 + 0][1 + 0] :  1
shapes[5][0][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][0][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][1][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
불가능
shapes[5][1][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][1][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][2][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
불가능
shapes[5][2][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][2][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
grid :  2 2
0번째 격자
shapes[0][0][0] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
가능
grid[2 + 0][2 + 0] :  1
shapes[0][0][1] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
불가능
shapes[0][0][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][1][0] :  1
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형있음
불가능
shapes[0][1][1] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][1][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][0] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][1] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
shapes[0][2][2] :  0
[1, 1, 0]
[1, 0, 0]
[0, 0, 0]
도형없음
1번째 격자
shapes[1][0][0] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
가능
grid[2 + 0][2 + 0] :  1
shapes[1][0][1] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[1][0][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][1][0] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][1][1] :  1
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[1][1][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][0] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][1] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
shapes[1][2][2] :  0
[1, 1, 0]
[0, 1, 0]
[0, 0, 0]
도형없음
2번째 격자
shapes[2][0][0] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
가능
grid[2 + 0][2 + 0] :  1
shapes[2][0][1] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][0][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][1][0] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[2][1][1] :  1
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[2][1][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][0] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][1] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[2][2][2] :  0
[1, 0, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
3번째 격자
shapes[3][0][0] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][0][1] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[3][0][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][1][0] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[3][1][1] :  1
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형있음
불가능
shapes[3][1][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][0] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][1] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
shapes[3][2][2] :  0
[0, 1, 0]
[1, 1, 0]
[0, 0, 0]
도형없음
4번째 격자
shapes[4][0][0] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
가능
grid[2 + 0][2 + 0] :  1
shapes[4][0][1] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
불가능
shapes[4][0][2] :  1
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형있음
불가능
shapes[4][1][0] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][1][1] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][1][2] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][0] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][1] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
shapes[4][2][2] :  0
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]
도형없음
5번째 격자
shapes[5][0][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
가능
grid[2 + 0][2 + 0] :  1
shapes[5][0][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][0][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][1][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
불가능
shapes[5][1][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][1][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][2][0] :  1
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형있음
불가능
shapes[5][2][1] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
shapes[5][2][2] :  0
[1, 0, 0]
[1, 0, 0]
[1, 0, 0]
도형없음
8

'알고리즘 > CodeTree' 카테고리의 다른 글

[코드트리] 왕실의 기사 대결 | 삼성 SW 역량테스트 2023 하반기 오전 1번 문제  (0) 2024.04.13
[코드트리] 포탑 부수기 | 삼성 SW 역량테스트 2023 상반기 오전 1번 문제  (0) 2024.04.10
[코드트리] 메이즈러너 | 삼성 SW 역량테스트 2023 상반기 오후 1번 문제  (0) 2024.04.10
[코드트리] 코드트리빵 | 삼성 SW 역량테스트 2022 하반기 오후 1번 문제  (0) 2024.04.10
[CodeTree] 행복한 수열의 개수 | 완전탐색  (0) 2024.03.30

https://www.codetree.ai/missions/2/problems/number-of-happy-sequence/description

n, m = map(int, input().split()) # 3, 2
grid = [list(map(int, input().split())) for _ in range(n)] 
# [[1, 2, 2], [1, 3, 4], [1, 2, 3]]
seq = [0 for _ in range(n)] 
# [0, 0, 0]

def is_happy_sequence(): 
    consecutive_count, max_ccnt = 1, 1

    # [1, 2, 2] in seq ver
    # [1, 1, 1] in seq hor
    for i in range(1, n): # 1~3 (1, 2)
        if seq[i - 1] == seq[i]:
            # seq[0] == seq[1] / seq[1] == seq[2]
            consecutive_count += 1
        else:
            # seq[0] != seq[1] / seq[1] != seq[2]
            consecutive_count = 1

        max_ccnt = max(max_ccnt, consecutive_count)
 
    return max_ccnt >= m # max_ccnt >= 2


num_happy = 0
 
for i in range(n):
    seq = grid[i][:]
    # [1, 2, 2] in seq ver
    # [1, 3, 4] in seq ver
    # [1, 2, 3] in seq ver
    if is_happy_sequence(): # True 면
        num_happy += 1
 
for j in range(n): # 0~3 (0, 1, 2)
    for i in range(n): # 0~3 (0, 1, 2)
        seq[i] = grid[i][j] # grid[0][0] / grid[1][1] / grid[2][2]
        '''
        1 in seq hor
        1 in seq hor
        1 in seq hor
        [1, 1, 1]
        
        2 in seq hor
        3 in seq hor
        2 in seq hor
        [2, 3, 2]
        
        2 in seq hor
        4 in seq hor
        3 in seq hor
        [2, 4, 3]
        ''' 
    if is_happy_sequence():
        num_happy += 1

print(num_happy)

 

쉽지 않다

'알고리즘 > CodeTree' 카테고리의 다른 글

[코드트리] 왕실의 기사 대결 | 삼성 SW 역량테스트 2023 하반기 오전 1번 문제  (0) 2024.04.13
[코드트리] 포탑 부수기 | 삼성 SW 역량테스트 2023 상반기 오전 1번 문제  (0) 2024.04.10
[코드트리] 메이즈러너 | 삼성 SW 역량테스트 2023 상반기 오후 1번 문제  (0) 2024.04.10
[코드트리] 코드트리빵 | 삼성 SW 역량테스트 2022 하반기 오후 1번 문제  (0) 2024.04.10
[CodeTree] 트로미노 | 완전탐색  (0) 2024.03.30

+ Recent posts

티스토리툴바