백준2615번 파이썬 문제풀이(오목)

 

---

이 문제는 bfs와 비슷하게 움직일 수 있는 좌표를 리스트로 저장해놓고 푸는 것이 편하다. 전체 코드는 다음과 같다.

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

dx = [+1, +1, 0, -1]  # 행이동 하,우하,우,우상
dy = [0, +1, +1, +1]  # 열이동 하,우하,우,우상


def solution():
    for k in range(len(omok)):
        for h in range(len(omok[k])):

            if omok[k][h] != 0:
                x, y = k, h  # 현재 좌표를 저장

                for i in range(4):  # 각 방향 이동
                    nx = x + dx[i]
                    ny = y + dy[i]

                    if nx < 0 or nx >= len(omok) or ny < 0 or ny >= len(omok):
                        continue

                    startx, starty = x, y

                    count = 1

                    old_x, old_y = x, y  # 기존 x,y 값을 좌표계산을 위해 저장해놓는다.

                    # 좌표를 이동한 상태에서 만약 같은방향으로 같은 색 바둑이 있으면 그쪽으로 개수를 세면서 더 이동한다.
                    while True:
                        # 만약 다음 바둑이 현 바둑 색하고 똑같다면
                        if omok[old_x][old_y] == omok[nx][ny]:
                            count += 1  # 개수 1개 추가
                        else:  # 만약 색이 다르다면 반복문을 돌필요가 없기 때문에 반복문 탈출
                            break

                        # 만약 바둑 개수가 5개라면
                        if count == 5:
                            if len(omok) > nx + dx[i] >= 0 and len(omok) > ny + dy[i] >= 0:
                                if omok[nx][ny] == omok[nx + dx[i]][ny + dy[i]]:  # 6목이므로
                                    break

                            if 0 <= startx - dx[i] < len(omok) and len(omok) > starty - dy[i] >= 0:
                                if omok[startx][starty] == omok[startx - dx[i]][starty - dy[i]]:  # 6목이므로
                                    break

                            return [startx + 1, starty + 1, omok[startx][starty]]

                        old_x, old_y = nx, ny  # 현재 좌표를 다음 이동 좌표로 저장
                        nx, ny = old_x + dx[i], old_y + dy[i]  # 다음 이동 좌표를 그 다음 다음 이동 좌표로 저장

                        # 만약 새로운 좌표가 범위를 벗어난다면 더이상 반복문을 돌 필요가 없으므로 탈출
                        if nx >= len(omok) or ny >= len(omok) or nx < 0 or ny < 0:
                            break


result = solution()

if result is None:
    print(0)
else:
    print(result[2])
    print(result[0], result[1])

 

---

해당 문제를 처음에는 저렇게 접근하지 않았고 일일이 하나씩 다 구현을 했다. 즉, 전체적으로 이중반복문을 돌면서 각각의 원소에서 아래,오른쪽,왼쪽대각선아래,오른쪽대각선아래 이렇게 4개로 구분하였다.  무식하지만 이런식으로 비슷하게 하드 코딩으로 구현하는것도 전체적인 개념을 이해하는 데 있어서 나쁘지는 않다.

 

omok = []
for _ in range(19):
    omok.append(list(map(int, input().split())))

result = []


def solution():
    global result

    for i in range(len(omok)):
        for j in range(len(omok[i])):
            # 만약 바둑이 있다면
            if omok[i][j] != 0:
                # 1st. 가로로 오목 이상일 때
                if j != len(omok[i]) - 1 and omok[i][j] == omok[i][j + 1]: 
                    if j != 0 and omok[i][j - 1] != omok[i][j]:
                        for k in range(j, len(omok) - 1):
                            if omok[i][k] == omok[i][k + 1]:
                                result.append((i, k))
                            else:
                                break
                    elif j == 0:
                        for k in range(j, len(omok) - 1):
                            if omok[i][k] == omok[i][k + 1]:
                                result.append((i, k))
                            else:
                                break

                    if len(result) == 4:
                        return omok[i][j]
                    else:
                        result = []

                # 2nd. 세로로 오목 이상일 때
                if i != len(omok) - 1 and omok[i][j] == omok[i + 1][j]:  
                    if i != 0 and omok[i - 1][j] != omok[i][j]:
                        for k in range(i, len(omok) - 1):
                            if omok[k][j] == omok[k + 1][j]:
                                result.append((k, j))
                            else:
                                break
                    elif i == 0:
                        for k in range(i, len(omok) - 1):
                            if omok[k][j] == omok[k + 1][j]:
                                result.append((k, j))
                            else:
                                break

                    if len(result) == 4:
                        return omok[i][j]

                    else:
                        result = []

                # 3th. 오른쪽하단으로 오목 이상일 때
                if i != len(omok) - 1 and j != len(omok[i]) - 1 and omok[i][j] == omok[i + 1][j + 1]:
                    if i != 0 and j != 0 and omok[i - 1][j - 1] != omok[i][j]:
                        h = j
                        for k in range(i, len(omok) - 1):
                            if omok[k][h] == omok[k + 1][h + 1]:
                                result.append((k, h))
                                h += 1
                                if h >= len(omok[i]) - 1:
                                    break
                            else:
                                break

                    elif i == 0 or j == 0:
                        h = j
                        for k in range(i, len(omok) - 1):
                            if omok[k][h] == omok[k + 1][h + 1]:
                                result.append((k, h))
                                h += 1
                                if h >= len(omok[i]) - 1:
                                    break
                            else:
                                break

                    if len(result) == 4:
                        return omok[i][j]

                    else:
                        result = []

                # 4th. 왼쪽하단으로 오목이상일때
                if j != 0 and i != len(omok) - 1 and omok[i][j] == omok[i + 1][j - 1]:  
                    if i != 0 and j != len(omok[i]) - 1 and omok[i - 1][j + 1] != omok[i][j]:
                        h = j
                        for k in range(i, len(omok) - 1):
                            if omok[k][h] == omok[k + 1][h - 1]:
                                result.append((k, h))
                                h -= 1
                                if h <= 0:
                                    break

                            else:
                                break
                    elif i == 0 or j == len(omok) - 1:
                        h = j
                        for k in range(i, len(omok) - 1):
                            if omok[k][h] == omok[k + 1][h - 1]:
                                result.append((k, h))
                                h -= 1
                                if h <= 0:
                                    break

                            else:
                                break

                    if len(result) == 4:
                        result.append((result[3][0] + 1, result[3][1] - 1))
                        result.reverse()
                        return omok[i][j]

                    else:
                        result = []


color = solution()
if color is None and len(result) == 0:
    print(0)
else:
    print(color)
    print(result[0][0] + 1, result[0][1] + 1)