태야

<내 코드>

E, S, M = map(int, input().split())

e, s, m = 1, 1, 1
year = 0
while True:
    year += 1

    if e == E and s == S and m == M:
        print(year)
        break

    e += 1
    s += 1
    m += 1

    if e == 16:
        e = 1
    if s == 29:
        s = 1
    if m == 20:
        m = 1

<내 코드>

import copy
heights = [int(input()) for _ in range(9)]

for i in range(8):
    tmp = copy.deepcopy(heights)
    tmp[i] = 0
    for j in range(i+1, 9):
        tmp_num = tmp[j]
        tmp[j] = 0
        if(sum(tmp) == 100):
            ans = tmp
            break
        tmp[j] = tmp_num
ans.sort()
for i in ans:
    if i != 0:
        print(i)

얇은 복사와 깊은 복사의 차이를 알 수 있는 문제였다. 일반 copy는 외부적으로는 다른 객체가 생성되나 내부 요소에는 결국 같은 객체를 가리키고 있다는 것을 알았다. 이것을 방지하기 위해 deepcopy를 해주면 외, 내부 모두 다른 새로운 객체로 만들 수 있다.

<내 코드>

N = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))

A.sort()
B.sort(reverse=True)

num = 0
for i in range(N):
    num += A[i]*B[i]

print(num)

<내 코드>

N, M = map(int, input().split())

n_p = [input() for _ in range(N)]
m_p = [input() for _ in range(M)]

# 교집합
result = list(set(n_p) & set(m_p))

print(len(result))
for i in sorted(result):
    print(i)

집합 자료형의 교집합 성질을 이용해 두 리스트의 공통 요소를 찾는다.

교집합 - '&'

합집합 - ' | '

차집합 - ' - '

<내 코드>

N = int(input())
cards = list(map(int, input().split()))
M = int(input())
nums = list(map(int, input().split()))

cards.sort()


for i in range(M):
    low, high = 0, N-1
    while low <= high:
        mid = (low + high) // 2
        if cards[mid] == nums[i]:
            print(1, end=" ")
            break
        elif cards[mid] < nums[i]:
            low = mid + 1
        else:
            high = mid - 1

        if low > high:
            print(0, end=" ")
            break

처음에 데이터 양을 생각하지 못하고 브루트포스처럼 풀었었다..

정렬된 리스트를 이분탐색으로 범위를 줄여나가면 많은 데이터에서 빠른 시간에 탐색이 가능하다.

<내 코드>

N, L = map(int, input().split())
pipe = sorted(list(map(int, input().split()))) # 입력을 정렬

cnt = 1
start = pipe[0]

for i in pipe:
    leng = start + L - 1

    if i <= leng:
        continue
    else:
        start = i
        cnt += 1

print(cnt)

문제 자체는 상당히 간단하다. 여기서 함정이 파이프 위치 입력 값을 정렬된 값으로 주는게 아니기 때문에 입력을 정렬 해주는 것이 중요하다. 

<내 코드>

from collections import deque


def bfs(s):
    q = deque()
    visited = [0 for _ in range(n+1)]

    q.append(s)
    visited[s] = 1

    while q:
        x = q.popleft()

        for i in tree[x]:
            if visited[i] == 0:
                visited[i] = 1
                result[i] = result[x] + 1
                q.append(i)


n = int(input())
a, b = map(int, input().split())
m = int(input())
tree = [[] for _ in range(n+1)]
result = [0 for _ in range(n+1)]

for _ in range(m):
    x, y = map(int, input().split())
    tree[x].append(y)
    tree[y].append(x)

bfs(a)
if result[b] != 0:
    print(result[b])
else:
    print(-1)

BFS로 그래프를 탐색하며 현재 탐색하는 노드와 연결된 노드에 현재 노드 값의 +1을 한다. 즉, 연결된 노드를 이동하는 것을 의미한다.

이런 식으로 모든 노드들을 탐색을 마치면 찾고자 하는 노드의 인덱스의 값을 출력해주면 된다.

<내 코드>

import sys
sys.setrecursionlimit(10**6)

n = int(input())
in_order = list(map(int, input().split()))
post_order = list(map(int, input().split()))

pos = [0]*(n+1)
for i in range(n):
    pos[in_order[i]] = i

# 전위 순회
def divide(in_start, in_end, p_start, p_end):

    if(in_start > in_end) or (p_start > p_end):
        return

    parents = post_order[p_end]  # 후위순회에서 부모노드 찾기
    print(parents, end=" ")

    left = pos[parents] - in_start  # 왼쪽인자 갯수
    right = in_end - pos[parents]  # 오른쪽인자 갯수

    divide(in_start, in_start+left-1, p_start, p_start+left-1)  # 왼쪽 노드
    divide(in_end-right+1, in_end, p_end-right, p_end-1)  # 오른쪽 노드


divide(0, n-1, 0, n-1)

후위 순회에서 부모 노드를 찾아 중위 순회에서 기준으로 삼아 왼쪽, 오른쪽 나눈다. 그리고 왼쪽 자식 트리 노드, 오른쪽 자식 트리 노드를 순회하며 앞의 과정을 반복한다.