태야

<내 코드>

n = int(input())
memo = [0 for _ in range(101)]

for i in range(0, 4):
    memo[i] = 1
for j in range(4, 6):
    memo[j] = 2

for _ in range(n):
    m = int(input())
    for k in range(6, m+1):  # 6 ~ m-1
        memo[k] = memo[k-1] + memo[k-5]

    print(memo[m])

피보나치 수열과 비슷한 맥락으로 규칙을 찾아 점화식을 세우면 간단하게 풀 수 있었다.

인덱스 0번 ~ 4번까지는 1과 2로 넣어주고 그 다음부터는 점화식을 통해 값을 구해나가는 구조였다. 인덱스 값을 0번째 부터 설정해서 뒤에서 조금 헷갈린거 말고는 크게 어렵지 않았다.

<내 코드>

n = int(input())
memo = [0 for i in range(n+1)]
memo[1] = 1
for i in range(2, n+1):
    memo[i] = memo[i-1]+memo[i-2]

print(memo[-1])

처음에 재귀호출을 통해 풀었을 때, 예상대로 시간초과가 났다. 

Bottom-up은 바닥에서 올라오는 것, 즉, 작은 문제부터 시작해서 작은 문제를 점점 쌓아 큰 문제를 푸는 것이다. 첫 번째 피보나치 수를 구하는 문제와 두 번째 피보나치 수를 구하는 문제를 풀면 세 번째 피보나치 수를 구하는 문제를 풀 수 있다. 두 번째 피보나치 수를 구하는 문제와 세 번째 피보나치 수를 구하는 문제를 풀면 네 번째 피보나치 수를 구하는 문제를 풀 수 있다....이걸 반복하면 n번째 피보나치 수를 구할 수 있다.

<내 코드>

def binarySearch(M, tree):
    start = 1
    end = max(tree)

    while start <= end:
        leng = 0
        mid = (start + end) // 2

        for i in tree:
            if i >= mid:
                leng += i - mid

        if leng >= M:
            start = mid + 1
        else:
            end = mid - 1

    return end


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

sortTree = sorted(tree)
print(binarySearch(M, sortTree))

이분 탐색 알고리즘을 이용해서 푸는 문제다. 알고리즘만 알고 있으면 생각보다 간단한 문제였다. 같은 코드로 채점 했는데 pypy3는 588ms가 걸리고 python3는 2984ms 가 걸리면서 다소 큰 차이가 있었다. 

<내 코드>

n = int(input())
A_num = list(map(int, input().split()))
sorted_A = sorted(A_num)

m = int(input())
M_num = list(map(int, input().split()))


def binary_search(M, sorted_A):
    start = 0
    end = len(sorted_A)-1

    while start <= end:
        mid = (start + end) // 2

        if(m == sorted_A[mid]):
            return print(1)
        elif (m > sorted_A[mid]):
            start = mid + 1
        else:
            end = mid - 1
    return print(0)


for m in M_num:
    binary_search(m, sorted_A)

이분 탐색 알고리즘 문제다. 이분 탐색은 미리 정렬된 리스트에서 값을 찾아나가는 알고리즘이다. 정렬된 자료에서 중앙값을 찾은 다음 찾으려는 값과 비교한다. 중앙값이 더 크면 찾으려는 값이 오른쪽에 있는 것이기에 오른쪽으로 범위를 좁히고, 중앙값이 더 작다면 왼쪽으로 범위를 좁혀 찾아나간다. 비교하는 값이 존재한다면 1을 프린트하고, 없다면 0을 프린트한다.

<내 코드>

n, k = map(int, input().split())
people = [i for i in range(1, n+1)]
key = 0
temp = k - 1
order = []
while people:
    key = (key+temp) % len(people)
    order.append(people.pop(key))

print('<'+', '.join(map(str, order))+'>')

순열 규칙을 찾으면 간단하게 해결되는 문제였다. 

<내 코드>

case = int(input())
for _ in range(case):
	# n : 자료 개수 , m : 찾고자 하는 자료 위치
    n, m = map(int, input().split())
    imp = list(map(int, input().split()))
    temp = [0 for _ in range(n)] #리스트 표현식으로 0인 리스트 생성
    temp[m] = 1 # 찾고자 하는 m번째를 1로 표시
    cnt = 0

    while imp:
        if imp[0] == max(imp):
            cnt += 1
            if temp[0] == 1:
                print(cnt)
                break
            else:
                imp.pop(0)
                temp.pop(0)
        else:
            imp.append(imp[0])
            temp.append(temp[0])
            del(imp[0])
            del(temp[0])

- 중요도를 표시하는 imp 입력을 리스트로 만든다.

- imp 리스트와 비교하기 위한 temp 리스트를 만든다.

- imp[0]이 젤 큰 값인지 판단해, 아니라면 imp, temp 첫 요소를 뒤로 보내고 한 칸씩 땡긴다.

- imp[0]이 최댓값이면서 찾고자 하는 값이면 cnt 값을 출력하고 종료한다. 만약 찾고자 하는 값이 아니면 지우고 한 칸씩 땡긴다.

<내 코드>

from collections import deque
n = int(input())
nums = deque()

for i in range(1, n+1):
    nums.append(i)


def que():
    cnt = 0
    while(len(nums) >= 1):
        cnt += 1
        if(len(nums) == 1):
            return nums[0]

        if(cnt % 2 == 1):
            nums.popleft()

        elif(cnt % 2 == 0):
            nums.append(nums.popleft())


print(que())

처음에 deque 사용하지 않고 pop() 2개를 사용했더니 역시나 시간 초과가 났다.. 

카운트를 이용해 홀수, 짝수 순서에 따라 카드 제거 & 카드 뒤로 이동을 구현했다.

<내 코드>

import sys
from collections import deque

n = int(sys.stdin.readline())
deque = deque()


def push(queque, x):
    deque.append(x)


def pop(deque):
    if(not deque):
        return -1
    else:
        return deque.popleft()


def size():
    return len(deque)


def empty():
    if(not deque):
        return 1
    else:
        return 0


def front():
    if(not deque):
        return -1
    else:
        return deque[0]


def back():
    if(not deque):
        return -1
    else:
        return deque[-1]


for i in range(n):
    oper = sys.stdin.readline().split()

    if (oper[0] == "push"):
        push(deque, oper[1])
    elif(oper[0] == "pop"):
        print(pop(deque))
    elif(oper[0] == "size"):
        print(size())
    elif(oper[0] == "empty"):
        print(empty())
    elif(oper[0] == "front"):
        print(front())
    elif(oper[0] == "back"):
        print(back())

이 문제는 시간 복잡도가 O(1)이 되어야 하는데, 일반적인 리스트의 pop() 함수를 사용하면 첫 번째 요소를 pop 할 때는 O(n)의 시간이 소요된다. 그래서 collections의 deque를 사용했다. pop 부분에서 popleft를 이용해 시간을 단축시킬 수 있다. deque는 스택과 큐를 합친 자료구조이다.