38-pknujsp

[pknujsp]

🔗 문제 링크

자물쇠와 열쇠

✔️ 소요된 시간

2시간, 도저히 안 떠올라서 풀이보고 공부

✨ 수도 코드

NxN 크기의 자물쇠와 MxM 크기의 열쇠가 있고, 열쇠를 회전시키거나 한칸 씩 이동시켜보면서 자물쇠에 열쇠가 끼워지는지 확인하는 문제

자물쇠와 열쇠의 최대크기가 20x20 이하이므로, 완전 탐색으로 풀 수 있다.

1. 자물쇠의 크기를 3배 키운다

• 열쇠를 상하좌우로 이동시켰을 때 자물쇠를 벗어나는 경우가 생긴다
• 이 때 네 방향에 대해서 벗어난 상태인지 확인을 하는 로직을 작성해야 하는데 굉장히 복잡해진다
• 수월하게 코드를 작성하기 위해서 3배 만큼 키워서 진행할 수 있다.
• 1행 1열 부터 N * 2행 N * 2열 까지 열쇠를 이동시켜보면서 완전 탐색을 수행한다.

• 전혀 떠올리지 못한 부분
• 엄청 복잡한 반복문과 분기문을 사용해서 열쇠를 돌리는 것만 생각했다

2. 네 번 반복 : 한번 회전하고 열쇠가 끼워지는지 모든 경우 탐색

• 90도 회전한다
• 열쇠를 자물쇠와 맞물릴 때 까지 한 칸씩 이동시켜본다
  • 특정 칸 만큼 이동하는 방법은 알맞는 자물쇠 배열 위치에
  • 열쇠 배열의 원소 값을 각각 더해보는 식으로 할 수 있다
  • 자물쇠 배열과 열쇠 배열의 원소 각각의 합이 모두 1 이라면 끼워진 것이다
  • 열리면 True 를 반환하여 종료한다
  • 자물쇠가 열리지 않으면 자물쇠 배열 원소를 모두 복구시킨다

열쇠 회전 방법

• C 열의 모든 원소를 그대로 C 행으로 만들면 된다.
• 열쇠 배열의 행을 반대로 뒤집어서 일일이 회전한 열쇠 배열에 값을 대입하도록 구현했는데
• 파이썬의 zip 함수를 사용하면 한 줄로 구현할 수 있음을 알게되었다

rev_key = key[::-1]
key = []
for c in range(k):
    row = []
    for r in range(k):
        row.append(rev_key[r][c])
    key.append(row)

"""
열쇠를 돌리는 로직은 한 줄로도 구현가능 합니다
key = [row for row in zip(*reversed(key))]
"""

3. 어떠한 경우에도 안 열리면 False 를 반환한다

# 자물쇠의 중간 부분이 모두 1인지 확인
def is_valid(new_lock):
    length = len(new_lock) // 3
    
    for r in range(length, length * 2):
        for c in range(length, length * 2):
            if new_lock[r][c] != 1:
                return False
            
    return True

def solution(key, lock):
    n = len(lock)
    k = len(key)
    new_lock = [[0] * (n * 3) for _ in range(n * 3)]
    
    for r in range(n):
        for c in range(n):
            new_lock[r + n][c + n] = lock[r][c]
            
    for _ in range(4):
        rev_key = key[::-1]
        key = []
        for c in range(k):
            row = []
            for r in range(k):
                row.append(rev_key[r][c])
            key.append(row)
        
        """
        열쇠를 돌리는 로직은 한 줄로도 구현가능 합니다
        key = [row for row in zip(*reversed(key))]
        """

        for r in range(n * 2):
            for c in range(n * 2):
                # 자물쇠에 열쇠를 끼운다
                for i in range(k):
                    for j in range(k):
                        new_lock[r + i][c + j] += key[i][j]
                        
                # 자물쇠에 열쇠가 딱 들어갔는지 확인
                if is_valid(new_lock):
                    return True
                
                # 자물쇠에서 열쇠를 빼서 복구시킨다
                for i in range(k):
                    for j in range(k):
                        new_lock[r + i][c + j] -= key[i][j]
    return False

📚 새롭게 알게된 내용

[H0ngJu]

3배를 더 키워서 접근한다는 건 생각도 못했는데 확실히 키우니까 배열에서 벗어난 경우의 처리가 수월하네요.. 벗어난 경우, 배열을 추가로 확장할 필요 없고, 움직일 때마다 자물쇠+열쇠의 값이 모두 1이면 되니까요

문제 푸느라 수고많으셨습니다 🔥🔥

[H0ngJu]

자두나무 문제보고 zip이 list끼리 index를 묶어서 tuple로 반환하는 함수구나 했는데 *reversed(key)로 각 index 원소에 접근해서 tuple로 묶어주면 회전이 되는군요 .... 응용이 이렇게 되네요

코드가 진짜 소름이 돋네요 🫢👍

[tgyuuAn]

def make_new_lock(lock):
    new_lock = []

    for _ in range(len(lock)):
        new_lock.append([2 for _ in range(len(lock[0])*3)])

    for row_lock in lock:
        temp = []
        temp.extend([2 for _ in range(len(row_lock))])
        temp.extend(row_lock)
        temp.extend([2 for _ in range(len(row_lock))])
        new_lock.append(temp)

    for _ in range(len(lock)):
        new_lock.append([2 for _ in range(len(lock[0])*3)])

    return new_lock

def rotate_key(key):
    rotated_key = []

    for col in range(len(key[0])):
        
        temp = []
        for row in range(len(key)):
            temp.append(key[len(key)-row-1][col])

        rotated_key.append(temp)

    return rotated_key

def solution(key, lock):
    new_lock = make_new_lock(lock)

    hole_count = 0

    for row in range(len(new_lock)):
        for col in range(len(new_lock)):
            if new_lock[row][col] == 0:
                hole_count += 1

    for _ in range(4):
        
        for row in range(len(lock)-len(key), len(lock)*2+1):
            for col in range(len(lock)-len(key), len(lock)*2+1):
                temp = 0

                for inner_row in range(row, row+len(key)):
                    for inner_col in range(col, col+len(key)):
                        if key[inner_row-row][inner_col-col] == 1 and new_lock[inner_row][inner_col] == 0:
                            temp += 1
                            

                        elif key[inner_row-row][inner_col-col] == 1 and new_lock[inner_row][inner_col] == 1:
                            temp += int(1e9)

                if hole_count == temp: return True

        key = rotate_key(key)

    return False

오마이가쉬...

완탐이면 조금만 더 노력하면 풀 수 있었는데...

완탐 문제의 문제점 : 과연 이 풀이가 맞는 걸까? 라고 생각하며 시도도 안해봄

반성하고 갑니다. (__)