Daim's blog

문제 풀이

leetcode에서는 기본 자료구조를 잘 활용할 수 있도록 다양한 문제를 준다. 이 문제도 트리의 순회문제이다. 순회를 할 때는 재귀를 이용할 수 있고 While문을 이용해서 모든 노드를 탐색할 수 있다. 나는 두가지 방식 모두를 활용해서 문제를 풀어보았다. 재귀를 별로 좋아하진 않은데 while문과 재귀 모두를 짜보게 되면 문제를 한단계 깊게 생각할 수 있어서 좋다.

파이썬 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

# Definition for a binary tree node.
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
 
 
# while loop
class Solution:
    def isUnivalTree(self, root) -> bool:
        node_list = [root]
        while node_list:
            cnode = node_list.pop()
            if cnode.val == root.val:
                if cnode.left: node_list.append(cnode.left)
                if cnode.right: node_list.append(cnode.right)
            else:
                return False
        return True
 
 
# Recursion
class Solution:
    def isUnivalTree(self, root) -> bool:
        if root:
            if root.left:
                if root.val != root.left.val:
                    return False
 
            if root.right:
                if root.val != root.right.val:
                    return False
        else:
            return True
        return self.isUnivalTree(root.left) and self.isUnivalTree(root.right)
 
 
 
if __name__ == "__main__":
    root = TreeNode(1)
    root.left = TreeNode(1)
    root.right = TreeNode(1)
    lnode = root.left
    rnode = root.right
    lnode.left = TreeNode(1)
    lnode.right = TreeNode(1)
    rnode.right = TreeNode(1)
 
 
    s = Solution()
    print(s.isUnivalTree(root))
 
Colored by Color Scripter

cs

Python으로 푸는 LeetCode 938. Range Sum of BST (Easy)

다임하게 — Fri, 14 Jun 2019 09:00:15 +0900

BST(이진 탐색 트리)가 있다.

입력받은 L, R의 범위에 속하는 값들의 합을 반환하는

프로그램을 짜시오.

문제 풀이

트리는 깊이가 있는 자료 구조이므로 개인적으로 나는 재귀로 문제를 해결하기가 쉽다. 나는 Node를 인자 값으로 넘기면 그 노드를 root로 하는 이진 탐색트리에서 L, R을 범위로 하는 Node를 찾아 값을 더하고 그 결과값을 반환해주는 checkChildBST라는 함수를 만들었다. 이런 재귀 함수를 짤 때에 가장 중요한 것은 재귀를 언제 중단하느냐에 대한 조건을 반드시 명시하는 것이라고 생각한다. 내 코드에서는 총 2번의 반환 작업이 일어난다.

- 현재의 노드가 아무런 자식을 가지고 있지 않은 leaf node일 경우에 결과 값을 반환한다. (24번째 줄)

- 현재 root의 val에 대해서 모든 가능성을 다 탐색하고 난 후의 결과 값을 반환한다(42번째 줄)

파이썬 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

# Definition for a binary tree node.
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
 
def _insert_node_into_binarysearchtree(node, data):
    if node == None:
        node = TreeNode(data)
    else:
        if (data <= node.val):
            node.left = _insert_node_into_binarysearchtree(node.left, data);
        else:
            node.right = _insert_node_into_binarysearchtree(node.right, data);
    return node
 
 
 
class Solution:
    def checkChildBST(self, root, result, l, r):
 
        # if leaf node, recursion must be closed
        if root == None:
            return result
 
        if root.val <= l:
            if root.val == l:
                result += root.val
            result = self.checkChildBST(root.right, result, l, r)
 
        if r <= root.val:
            if r == root.val:
                result += root.val
            result = self.checkChildBST(root.left, result, l, r)
 
        if l < root.val < r:
            result = self.checkChildBST(root.left, result + root.val, l, r)
            result = self.checkChildBST(root.right, result, l, r)
 
        # Returns the result of the tree of child
        return result
 
 
    def rangeSumBST(self, root, L: int, R: int) -> int:
        return self.checkChildBST(root, 0, L, R)
 
 
if __name__ == "__main__":
    root = _insert_node_into_binarysearchtree(None, 10)
    node = _insert_node_into_binarysearchtree(root, 5)
    node = _insert_node_into_binarysearchtree(root, 15)
    node = _insert_node_into_binarysearchtree(root, 3)
    node = _insert_node_into_binarysearchtree(root, 7)
    node = _insert_node_into_binarysearchtree(root, 18)
    node = _insert_node_into_binarysearchtree(root, 1)
    node = _insert_node_into_binarysearchtree(root, 6)
 
    s = Solution()
    print(s.rangeSumBST(root, 7, 15))
    print(s.rangeSumBST(root, 6, 10))
Colored by Color Scripter

cs

Python 클로저(closure) 이해하기

다임하게 — Tue, 11 Jun 2019 09:00:21 +0900

클로저(closure)란 자신이 정의된 스코프에 있는 변수를 참조하는 함수이다.

파이썬은 클로저를 지원한다.

이 포스팅은 Python의 클로저의 특성을 이해하기 위하여 작성되었으며,

"파이썬 코딩의 기술"이라는 책을 참고하였고

나중에 다시 보아도 이해하기 쉽도록 지금 내가 이해한 바를 바탕으로 설명을 추가하였다.

코드를 보고 클로저를 이해하자

1
2
3
4
5
6
7
8
9
10
11
12
13

def sort_priority(values, group):
    def helper(x):
        if x in group:
            return (0, x)
        return (1, x)
    values.sort(key=helper)
    print(values)
 
 
numbers = [8, 3, 1, 2, 5, 4, 7, 6]
group = {2 ,3, 5, 7} # 우선 순위가 높은 아이템
sort_priority(numbers, group)
print(numbers)  # [2, 3, 5, 7, 1, 4, 6, 8]

cs

무엇을 위한 코드인가

위의 코드에서는 리스트인 numbers를 파이썬에 내장된 sort 메서드를 사용하여 정렬하고 있다(line : 6). 위 코드에서는 단순히 numbers의 원소들의 크기 값을 비교하여 정렬하진 않는다. group 집합에 존재하는 우선순위 숫자들은 값에 상관없이 앞에 놓여야 하므로 사실상 정렬를 하는 조건이 2개인 셈이다. group 집합에 존재하는 값들을 앞에 정렬하고, (기존의 정렬 상태는 유지시키고) 그 안에서 다시 한번 원소의 크기에 따라 정렬한다. 이를 위해 클로저 함수 helper를 활용한다.

코드를 이해해보자

클로저 함수 helper를 이해해보자. sort_priority 함수를 보자. line 6번째 줄에서 sort 메서드의 key 인자로 helper 함수를 넘기고 있다(key=helper). 이때 helper 함수의 인자 값(x)으로는 values(파라미터로 전달된 numbers)의 원소들이 하나씩 전달된다. 그런데 helper 함수의 인자는 x 뿐인데 어디선가 튀어나온 group 변수가 사용되고 있다(line:3). 이게 무슨 일인가. helper 함수가 외부 함수인 sort_priority의 파라미터로 전달된 변수 group을 참조하고 있다. 그리고 아주 자연스럽게 helper 함수는 x가 group에 속해있는지를 판단하고(line : 3) 조건에 따라 적절한 튜플을 반환하고 있다. helper 함수가 group을 참조할 수 있는 것은 helper 함수가 클로저 함수이기 때문이다.

helper 함수의 반환값인 튜플은 리스트에 있는 각 아이템을 정렬하는데 활용된다. 파이썬에서는 튜플을 비교하는 특정한 규칙이 있는데, 먼저 Index 0으로 원소를 비교하고 그 다음으로 Index 1, Index2 ...Index N으로 진행한다. helper 클로저의 반환 값이 정렬 순서를 분리된 두 그룹으로 나뉘게 한 건 이 규칙 때문이다.

Python으로 푸는 백준 6359. 만취한 상범

다임하게 — Sun, 2 Jun 2019 09:00:46 +0900

백준 6359. 만취한 상범

기숙사 지하에는 n개의 방이 일렬로 늘어선 감옥이 있다.

각 방에는 벌점을 많이 받은 학생들이 구금되어 있다.

감옥 간수인 상범이가 문을 열고 닫는 게임을 했을 때,

모든 게임이 끝나고 난 후에 열린 문으로 도망친 학생의 수를 구하는 프로그램을 짜시오.

문제 조건

감옥에 주어진 N개의 방을 열고 닫는 게임을 한다.

1부터 n의 숫자가 될때까지 숫자들을 k(1<=k <=n)라고 한다.

k의 간격 만큼 떨어진 감옥의 방문이 열려 있으면 열고, 닫혀 있으면 닫는다.

문제 풀이

방문이 열려 있는지 닫혀있는지 기록된 dom이라는 리스트가 존재한다. 1부터 시작하는 k가 n이 될때까지 재귀가 돈다. 함수에서는 주어진 k의 간격만큼 떨어진 방문들을 열고 닫는다. 사실 이 문제는 재귀로 풀지 않고 2중 for문으로 푸는게 더 적합할 것 같으나 알고리즘의 분류가 DP로 되어 있으므로 그 방식대로 문제를 해결하였다.

파이썬 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import sys
input = sys.stdin.readline
 
 
def solve(dom, k, n):
 
    if k == n + 1:
        print(dom.count(1))
        return
    
    # k간격만큼 문 열고 닫기
    for i in range(k-1, n, k):
        if dom[i] == 0: dom[i] = 1
        elif dom[i] == 1: dom[i] = 0
    solve(dom, k+1, n)
 
 
if __name__ == '__main__':
    n = int(input().strip())
    for i in range(n):
        count = int(input().strip()) # 감옥의 총 수
        dom = [0]*count # 감옥
        solve(dom, 1, count)
 
Colored by Color Scripter

cs

Python으로 푸는 백준 2579. 계단 오르기

다임하게 — Sat, 1 Jun 2019 09:00:31 +0900

백준 2579. 계단 오르기

계단 아래 시작점부터 계단 꼭대기에 위치한 도착점까지 가는 게임이다.

계단에는 일정한 점수가 쓰여있으며 계단을 밟으면 그 계단에 쓰여있는 점수를 얻게 된다.

계단에 오르는 규칙을 지키며 계단의 꼭대기에 올랐을 때, 얻을 수 있는 총 점수 최댓값을 구하는 프로그램을 작성하시오.

문제 조건

계단을 오르는 규칙은 다음과 같다.

1. 계단은 한 번에 한 계단씩 또는 두 계단씩 오를 수 있다. 즉, 한 계단을 밟으면서 이어서 다음 계단이나, 다음 다음 계단으로 오를 수 있다.

2. 연속된 세 개의 계단을 모두 밟아서는 안 된다. 단, 시작점은 계단에 포함되지 않는다.(0층)

3. 마지막 도착 계단은 반드시 밟아야 한다.

문제 풀이

이 문제의 핵심은 계단을 오르는 규칙을 잘 지키며 계단 꼭대기에 올라갔을 때 얻을 수 있는 최댓값을 구하는 것이다. 이 문제는 DP(복잡한 문제를 간단한 여러 개의 문제로 나누어 푸는 방법)로 문제를 해결할 수 있지만 내가 DP로 문제들을 많이 풀어보지 않았기 때문에 이 문제에 어떻게 접근하고 어떤 값을 Memoization 해두는 것이 좋을지에 대해 감이 오지 않았다. 완전 탐색하는 방법으로도 문제는 풀 수 있겠지만 주어진 계단의 수가 커질 수록 시간 초과가 나올 수 밖에 없다.

이 문제는 연속된 세 개의 계단을 모두 밟아선 안된다는 조건 때문에 멘붕이 오기가 쉽다. 직전과 그 전전칸이 무엇인지에 대한 여부에 따라서 다음 칸을 밟아도 되는지 안되는지에 대한 여부가 결정된다는 것이므로! 사실 백준 1563. 개근상 문제처럼 연속해서 계단을 밟았는지에 대한 여부를 기록하면서 문제를 풀어나갈수도 있다.하지만 이 문제는 약간의 규칙만 발견하면 연속해서 계단을 밟았는지에 대한 정보를 기록할 필요 없이 더욱 DP스럽게(?) 문제를 풀어나갈 수 있다.

앞으로 어떤 계산을 밟을 것인가 vs 어떤 계단을 밟고 올라왔을까?

계단을 올라가는 것만 생각하지 말고, 이미 올라간 상태에서 이전에 내가 어떤 계단을 밟고 올라올지를 생각하는 방식으로 사고를 전환해보자.

앞으로 어떤 계단을 밟을 것인가 vs 어떤 계단을 밟고 올라왔을까?

생각해보자. 내가 현재 n번째 계단에 있다. 내가 오르기 전에 밟고 있던 계단의 경우의 수는 총 2가지이다. 두가지의 경우의 수 중에서 더 큰 값이 답이 된다.

첫 째, 한칸 전(n-1) 계단을 밟고 올라온 경우이며 이럴 땐 세번 연속 계단을 오를 순 없으므로 그 이전 계단은 그 전전인 (n-3)번째 계단이 된다.

두번 째, 두칸 전(n-2) 계단을 밟고 올라온 경우이다.

직전 칸에서 올라온 경우 vs 전전 칸에서 올라온 경우

중복된 계산을 피하기 위해서 내가 기록해 두어야 하는 값은 n칸 까지 올라왔을 때 얻을 수 있는 최댓값이며, 위의 그림을 모두 이해하였다면 코드를 짜는건 어렵지 않다.

파이썬 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

import sys
input = sys.stdin.readline
 
 
def solve(stair, n):
    dp = []
    dp.append(stair[0])
    for i in range(1, 3):
        if i == 1:
            dp.append(max(dp[i-1] + stair[i], stair[i]))
            continue
        dp.append(max(dp[i-2] + stair[i], stair[i-1] + stair[i]))
 
    for i in range(3, n):
        # i번째 계단으로 올라오기 위해 max(직전 계단을 밟은 경우, 직전 계단을 밟지 않은 경우)
        dp.append(max(stair[i] + stair[i-1] + dp[i-3], stair[i] + dp[i-2]))
    # print(dp)
    print(dp[-1])
 
 
if __name__ == "__main__":
    stair = []
    n = int(input().strip())
    for i in range(n):
        stair.append(int(input().strip()))
 
    solve(stair, n)
Colored by Color Scripter

cs

Python으로 푸는 백준 2163. 초콜릿 자르기

다임하게 — Fri, 31 May 2019 10:00:43 +0900

백준 2163. 초콜릿 자르기

정화가 N x M 크기의 초콜릿을 친구들과 나눠먹기 위하여 1 x 1 크기로 자르려고 한다.

최소 쪼개기 횟수로 초콜릿을 쪼개기 위해선 몇 번 쪼개야 하는지 구하는 프로그램을 작성하시오.

문제 풀이

이 문제는 크기마다 초콜릿을 쪼개는 수의 규칙을 찾아 문제를 풀 수 있다. 나는 수의 규칙을 찾아 문제를 풀었다.

가로가 N 조각이라는건 총 N-1 번 자르게 나눠져 있다는 점을 주의해서 문제를 해결하면 된다.

예를 들어, 5 x 3인 초콜릿이 주어졌다고 하자.

가로로 4 번을 잘라 1x3 짜리가 5조각이 나오고, 이 5조각을 각각 2 번씩 잘라야 1 x 1 짜리 초콜릿을 얻을 수 있다.

조건을 일반화 하면 N x M인 초콜릿이 주어졌다고 할 때,

가로로 (N-1)번 잘라 1xM 짜리가 N조각이 나오고, 이 N조각을 각각 (M-1)번씩 잘라야 1 x 1 짜리 초콜릿을 얻을 수 있다.

이를 식으로 만들게 되면 다음과 같다.

자르는 횟수 = (N-1) + N(M-1)

파이썬 코드

1
2
3
4
5
6
7
8
9
10
11

 
import sys
input = sys.stdin.readline
 
def solve(n, m):
    return (n-1) + n * (m-1)
 
 
if __name__ == "__main__":
    n, m = map(int, input().strip().split())
    print(solve(n, m))

cs

Python으로 푸는 백준 1563. 개근상

다임하게 — Thu, 30 May 2019 14:00:24 +0900

백준 1563. 개근상

한학기의 출석 일수 N이 주어졌을 때, 개근상을 받을 수 있는 경우의 수를 세는 프로그램을 작성하시오.

백준에서 푼 문제 리스트

Github에서 코드

문제 조건

출결 사항이 기록되는 출결은 출석, 지각, 결석이다.

개근상을 받을 수 없는 사람은 지각을 두 번 이상 했거나, 결석을 세 번 연속으로 한 사람이다.

문제 풀이

문제의 조건을 이해해 보자. 지각 횟수는 누적되고, 결석은 연속되지 않으면 초기화된다. 주어진 한 학기 출결 일 수 N일까지, 1일부터 차근차근 경우의 수를 살펴나갈 것이다. 매일 현재의 지각 횟수, 연속 결석 수를 확인하여, 문제 조건에 제시된 '개근상을 받을 수 없는 조건'에 해당되지는 여부를 확인한다. 이처럼 N일까지 매일 조건을 체크하면서 개근상을 받는 것이 가능한 경우의 수를 찾아 늘려가기 위하여 DP(큰 문제를 작은 문제로 쪼개 작은 문제부터 해결해 나가는 방법)를 적용해 문제를 풀어나간다.

매일 학생이 할 수 있는 출결 사항은 (1) 출석 (2) 지각 (3) 결석 3가지 경우의 수가 있다. N일까지 학생이 만들어 낼 수 있는 출결 기록의 경우의 수는 대층 생각했을 때 3^n 만큼이며 모든 경우의 수를 다 탐색한다고 한다면 그만큼의 재귀가 일어나야 한다(재귀 한도 초과가 예상). 이 문제에서는 최대한 재귀하는 수를 줄이기 위해선 여러가지 가지 치기가 필요하다. 다시 사용하는 값은 memoization 해주어야 하고(가지치기1), 지각을 두번 이상하였거나 결석을 3번 연속으로 한 경우에는 개근상을 받지 못하므로 0을 반환해주어서 불필요한 값을 더 이상 구하지 않도록 해줘야 한다(가지 치기2).

그렇다면 어떠한 값을 다시 사용하게 될거라 생각해 Memoization은 뭘 기록해주어야 하나. Memoization에는 K일째 되는날, 지각과 연속된 결석의 수를 고려하였을 때 N일까지 도달했을 때 개근상을 받을 수 있는 경우의 수를 기록할 것이다.

Key : Value

(K일, 지각한 횟수, 연속된 결석 수) : N일이 되었을 때, 개근상을 받을 수 있는 경우의 수

메모이제이션은 한번 계산 해둔 값을 재사용하기 위함이라고 이미 말한 적이 있다. 백준에 나와있는 4일을 예를 들어서 Memoization에 어떤 값을 저장하는지 보면 다음과 같다.

Memoization한 Memo의 원소들

{(3, 0, 0): 3, (3, 1, 0): 2, (3, 0, 1): 3, (2, 0, 0): 8, (3, 1, 1): 2,

(2, 1, 0): 4, (3, 0, 2): 2, (2, 0, 1): 7, (1, 0, 0): 19, (3, 1, 2): 1,

(2, 1, 1): 3, (1, 1, 0): 7, (2, 0, 2): 5, (1, 0, 1): 17, (0, 0, 0): 43}

Memoization에서 (0, 0, 0): 43의 의미는 0일 째에 지각도 없고, 연속된 결석도 없는 상태에서 N인 4일 째까지 개근상을 탈 수 있는 경우의 수를 모두 구한 값이다. (0, 0, 0)일때의 결과 값을 구하기 위해서는 1일 차에 출석(1, 0, 0), 지각(1, 1, 0), 결석(1, 0, 1)일 경우에 대한 모든 경우의 수를 구해야 하고, 출석(1, 0, 0)에 대한 경우의 수를 구하기 위해선 2일 차에 출석(2, 0, 0), 지각(2, 1, 0), 결석 (2,0,1)의 경우의 수를 합치면 된다. 결국 1일째부터의 모든 경우의 수를 구하는 문제를 2일째, 3일째, 4일째의 경우의 수를 각각 구하는 작은 문제로 나눠서 문제를 해결하며, 이러한 과정에서 중복되는 Key 값에 대해선 이미 계산한 값을 가져다가 쓰는 것이다. 이에 대해 실제로 모든 경우의 수를 그려서 구해보면 다음과 같다.

그림을 이해하기 위해서 하는 설명

형광펜으로 색칠한 Key 값들은 중복되기 때문에 Memoization에서 값을 기록하여 나중에는 재연산 없이 값을 가져다가 쓸 것이다. 잘 보면 1일차에 출석하였을 때 구해진 값들은, 1일차에 결석을 했을 때의 값을 구할 때 대부분 다시 구해야 하기 때문에 Memoization을 활용할 경우 연산의 양을 확실히 줄일 수 있음을 알 수 있다.

파란색으로 동그라미 친 경우는 해당 조건으로 N일까지 출결하여 개근상을 받을 수 있는 경우의 수이다. 1일차 출석(19) = 2일차 출석(8) + 2일차 지각(4) + 2일차 결석(7)이라는 사실을 보고 나면 DP를 이해가기가 더 쉽다.

빨간 줄이 그어진 경우는, 개근상을 받을 수 있는 조건에 위배된 케이스이다.

ㄴ 1일 차에 출석 했을 때의 모든 경우의 수 (19가지)

ㄴ 1일 차에 지각 했을 때의 모든 경우의 수 (7가지)

ㄴ 1일 차에 결석 했을 때의 모든 경우의 수 (17가지)

이 문제는 DP에 대한 감을 잡기 위하여 모든 경우의 수를 직접 그려서 확인해보았고 결과적으로 매우 도움이 되었다. DP 문제가 이해가 되지 않아서 이 포스팅을 찾으신 분들이라면 쉬운 DP 문제를 찾아서 작은 케이스의 모든 경우의 수를 직접 구해보면 DP의 단짝인 Memoization을 어떤 값을 저장해놔야 할지에 대해서도 감이 잡힐 거라고 생각한다.

그럼에도 불구하고 런타임 에러가 날 경우

주어진 N이 1,000일 경우에는 파이썬에서 정해놓은 재귀호출 수보다 많은 호출이 일어나면서 RecursionError가 나게 되어 런타임 에러가 날 수도 있다. 의도적으로 파이썬의 재귀호출 수를 증가시키자. 사실 백준의 대다수 문제들이 다른 언어와 같은 알고리즘으로 풀더라도 재귀호출 에러가 나는 경우가 많은 것 같다. 내 알고리즘에 확신이 있을 경우에는나는 재귀 호출 수를 늘려본다. 그럼 대부분 맞다.

sys.setrecursionlimit(1000000000)

파이썬 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

import sys
input = sys.stdin.readline
sys.setrecursionlimit(1000000000)
memo = {} # memoization
 
def dp(total, day, late, abs):
 
    # 지각이 2번 이상이면 fail
    if 2 <= late:
        return 0
 
    # 결석 3연속이면 fail
    if 3 <= abs:
        return 0
 
    # 개근상 조건 충족
    if day == total:
        return 1
 
    # memoization 기록 가져오기
    # day, late, abs가 다음과 같은 값일 경우 개근상을 받을 수 있는 경우의 수
    if (day, late, abs) in memo:
        return memo[(day, late, abs)]
 
    # day째 되는 날에, 그 이후 날들에 출석하거나 지각하거나,결석하였을 때 개근상을 받을 수 있는 경우의 수에 대한 기록
    memo[(day, late, abs)] = dp(total, day + 1, late, 0) + dp(total, day +1, late +1, 0) + dp(total, day +1, late, abs + 1)
    return memo[(day, late, abs)]
 
 
if __name__ == "__main__":
    total = int(input().strip())
    # 출석 일 수, 지각수, 연속 결석 수
    print(dp(total, 0, 0, 0) % 1000000)
Colored by Color Scripter

cs

Python으로 푸는 백준 1793. 타일링

다임하게 — Wed, 29 May 2019 21:00:28 +0900

백준 1793. 타일링

2 * N 직사각형을 2*1과 2*2 타일로 채우는 방법의 수를 구하는 프로그램을 작성하시오.

문제 풀이

이 문제를 이해하는데는 어렵지 않다. 다만 어떻게 풀지 막막할 뿐이다. 다이나믹 프로그래밍으로 문제를 풀기 위해서 문제를 자세히 들여다보자. 이 문제는 매번 다음 타일을 무엇을 두느냐를 결정하는 작은 문제로 나눠질 수 있다. 하나의 타일을 놓을때마다 (1) 2*1짜리를 놓을지, (2) 2*2 짜리를 놓을지, 아니면 (3)2*2를 만들기 위해서 1*2짜리를 2개를 합쳐 모양을 만들지를 고민한다.(2*1을 돌려놓으면 1*2가 된다) 다음에 놓을 수 있는 (1)(2)(3)을 이미지로 보면 아래와 같다.

다음에 놓을 수 있는 타일의 종류들

Case2와 Case3의 모양은 서로 같다. 그 말은 즉, Case2가 놓일 수 있는 크기에는 Case3도 놓을 수 있다는 의미이다. 두 경우의 수가 크기가 같기 때문에 다음 타일을 무엇을 둘지 고민할 때 Case1, Case2, Case3를 모두 고려할 필요 없이 Case1를 놓을 수 있는 경우와 Case2를 놓는 경우를 두배해준 값을 합쳐주면 된다. 코드를 보면 더 이해하기가 쉽다.

런타임 에러 처리 - 테스트 케이스의 수가 한정되지 않은 경우의 입력 처리

이 문제에서 가장 어려운 점은 예제를 입력받는 부분이 아니었을까 싶다. 보통 백준의 문제들을 입력하는 테스트케이스의 수가 주어지는데 이 문제의 경우에는 테스트 케이스가 몇개 인지에 대해서 입력되는 값이 없다. 1년 전에 해당 문제와 관련된 질문글에 테스트 케이스의 수가 한정되지 않은 경우에 입력을 어떻게 받는지에 대한 글이 올라와있는데 While문으로 해결할 수 있다고 적혀 있다. 그러나 더이상의 입력이 없는데도 While문으로 입력을 받기 위해 대기하고 있으면 타일의 수를 구하는 코드가 맞더라도 런타임 에러가 나게 된다. (1년 전에는 Python 버전이 달랐는지 현재는 에러가 나는듯 하다) 나는 While문으로 입력값을 받고 있었는데도 에러가 나서 질문글을 찾아보게 되었고, 무슨 에러인지는 모르겠지만 백준 서버에서 에러가 난다면 이걸 Exception 처리를 통해 핸들링해봐야 겠다고 생각했다. 그래서 Try ~ except 처리문에서 에러가 발생 시 pass하여 주도록 함으로써 문제를 해결하였다.

1
2
3
4
5
6
7

memo = {}
try:
    while True:
        n = int(input().strip())
        print(dp(0, n, memo))
except:
    pass

cs

파이썬 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

import sys
input = sys.stdin.readline
 
def dp(start, n, memo):
 
    # 마지막 위치까지 타일링 완료
    if start == n:
        return 1
 
    # 범위를 초과한 타일 처리
    if n < start:
        return 0
 
    # 저장된 값 활용하기
    if (start, n) in memo:
        return memo[(start, n)]
 
    # memoization
    memo[(start, n)] = dp(start + 1, n, memo) + 2*dp(start+2, n, memo)
    return memo[(start, n)]
 
 
if __name__ == "__main__":
    memo = {}
    try:
        while True:
            n = int(input().strip())
            print(dp(0, n, memo))
    except:
        pass
Colored by Color Scripter

cs

Python으로 푸는 백준 1991. 트리 순회

다임하게 — Tue, 28 May 2019 19:00:39 +0900

1991 트리 순회

이 문제는 트리의 구조를 입력받아, 트리를 순회하는 전휘, 중위, 후위 순회 방식대로 값을 출력하는 문제이다. 트리의 기본 문제라고 할 수 있다.

github에서 코드 보기

문제 풀이

트리의 순회하는 방법으로는 전위 순회, 중위 순회, 후위 순회가 있다. 백준 1991 문제는 이진 트리의 순회에 관한 매우 기본적인 문제이다. 그럼에도 이 문제를 풀면서 난 매우 고전을 했다. 아무래도 트리를 구현하고나서 순회를 진행해야 하는데 트리를 구현하는 방식을 너무 쉽게 생각한 듯 하다.

1. 트리를 list(배열)로 구현한 방식 - 메모리 초과로 실패

내가 처음으로 푼 방법은 트리를 list(배열)로 구현한 방식이다. 문제에서 제안한 노드의 수는 최대 26개인데, 트리의 구조가 최악일 경우 level이 26일테고 이걸 리스트로 구현할 경우에는 최대 2^26 -1 개 만큼의 공간이 필요하게 된다. 나는 처음에 이게 과연 얼마나 큰 것인지 가늠을 하지 못했다. 26개이 노드이고 sys.getsizeof(['A'])로 측정한 사이즈 하나짜리의 리스트의 메모리의 크기는 72 bytes, 최대 2^26개의 메모리 공간이 필요하게 되는데 2^26 * 0.0703125KB(72 bytes) = 4718592KB = 4608MB 이다. 문제에서 메모리 제한이 128MB 였으므로 메모리 초과가 나올 수밖에 없었다. 리스트로 트리를 구현하게되면 리프노드의 경우에도 자식 노드가 비어 있음을 표현해주기 위해서 메모리 공간을 차지하게 되는데, 그때문에 불필요한 메모리가 많이 낭비되게 된다. 코드를 보고 헷갈리지 않게 말을 덧붙이자면, 아래 파이썬 코드에서 혹시 메모리를 줄일 수 있을까하여 list에 값을 추가한 후, ''.join()으로 string으로 변환시켜보았는데 생각해보니 값을 넣는 과정에서 이미 메모리 공간을 초과하였으므로 큰 효과는 없는 코드였다. 이 문제를 해결하기 위해서 dict를 활용해서 문제를 다시 풀게 되었다.

2. 트리를 dict로 구현한 방식 - 성공

dict로 구현할 경우에는 입력받는 부분을 컨테이너에 담기가 편하다.

노드의 값 : [왼쪽 노드의 값, 오른쪽 노드의 값]

형태로 저장되는 dict의 원소의 수는 최대 26개이며, 이는 list로 생성한 것보다 메모리를 훨씬 덜 차지한다. dict에서 key를 가지고 값을 찾아가는데는 O(1) 밖에 걸리지 않는다. 기존 코드를 활용해서 왼쪽 노드와 오른쪽 노드를 찾아가는 방식만 dict에서 찾도록 바꿔주면 문제는 쉽게! 풀린다. 만약, 이 문제를 풀다가 원인을 모르는 런타임 에러가 난다면 노드의 수가 1개인 경우를 고려해보자. 즉, 노드가 루트 'A'만 존재하는 경우이다. 이 부분을 고려해서 문제를 풀면 거의 대부분 문제 없이 문제를 맞출 수 있을 것 같다.

파이썬 코드 - 성공, dict 사용

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

import sys
input = sys.stdin.readline
 
# 전위 순회 (루트) (왼쪽 자식) (오른쪽 자식)
def preorder(tree, root):
    stack = []
    stack.append(root)
    result = ''
    while 0 < len(stack):
        data = stack.pop()
        result += data
 
        # 오른쪽 자식 노드 체크
        if tree[data][1] != '.':
            stack.append(tree[data][1])
 
        # 왼쪽 자식 노드 체크
        if tree[data][0] != '.':
            stack.append(tree[data][0])
    print(result) # ABDCEFG
 
 
# 중위 순회 (왼쪽 자식) (루트) (오른쪽 자식)
def inorder(tree, root):
    stack = []
    result = ''
    data = root
    stack.append(root)
    while True:
        # 왼쪽 자식 노드
        while tree[data][0] != '.':
            if data not in result:
                stack.append(tree[data][0])
                data = tree[data][0]
            else:
                break
 
        if 0 < len(stack):
            # 'D'
            data = stack.pop()
            result += data
            if tree[data][1] != '.':
                stack.append(tree[data][1])
                data = tree[data][1]
        else:
            break
    print(result) # DBAECFG
 
 
# 후위 순회 (왼쪽 자식) (오른쪽 자식) (루트)
def postorder(tree, root):
    stack = []
    result = ''
    stack.append(root)
    data  =root
 
    while True:
        # 왼쪽 자식 체크
        while tree[data][0] != '.':
            if tree[data][0] not in result:
                stack.append(tree[data][0])
                data = tree[data][0]
            else:
                break
 
        # 오른쪽 자식이 존재하는지를 먼저 체크하기 위해 pop() 하지 않고 값만 가져온다.
        last_data = stack[-1]
 
        # 오른쪽 자식이 존재하는지 체크
        if tree[last_data][1] == '.':
            # 오른쪽 자식이 없으면 그냥 출력
            result += stack.pop()
 
            # 다음 데이터를 지정해준다
            if stack:
                data = stack[-1]
            else:
                # stack이 비어 있으면 종료
                break
        else:
            # 오른쪽 자식이 있으면 다음의 규칙대로 해결
            #
            # 오른쪽 자식이 아직 나오지 않은 노드 -> stack에 추가
            if tree[data][1] not in result:
                stack.append(tree[data][1])
                data = tree[data][1]
            else:
                # 오른쪽 자식이 이미 나온 노드 -> 현재의 노드를 출력하고 start_index를 stack에 들어있는 노드로 바꿔준다.
                result += stack.pop()
                if 0 < len(stack):
                    data = stack[-1]
                else:
                    break
    print(result) # DBEGFCA
 
 
def solve(tree, root):
    preorder(tree, root) # ABDCEFG
    inorder(tree, root) # DBAECFG
    postorder(tree, root) # DBEGFCA
 
if __name__ == "__main__":
    n = int(input().strip())
    tree = {}
    root = None
    for i in range(n):
        info = input().strip().split(' ')
        tree[info[0]] = [info[1], info[2]]
 
    solve(tree, 'A')
Colored by Color Scripter

cs

파이썬 코드 - 실패, 메모리 초과, 배열 사용

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

import sys
import math
input = sys.stdin.readline
 
def preorder(tree):
    stack = []
    stack.append(tree[0])
    result = ''
    while 0 < len(stack):
        data = stack.pop()
        result += data
        index = tree.index(data)
 
        # 오른쪽
        if tree[2 * index + 2] != '.':
            stack.append(tree[2 * index + 2])
 
        # 왼쪽
        if tree[2*index + 1] != '.':
            stack.append(tree[2*index + 1])
    print(result) # ABDCEFG  (루트) (왼쪽 자식) (오른쪽 자식)
 
 
def inorder(tree):
    stack = []
    result = ''
    start_index = 0
    stack.append(tree[start_index])
    while True:
        while tree[2 * start_index + 1] != '.':
            stack.append(tree[2 * start_index + 1])
            start_index = 2*start_index + 1
        # stack ['A', 'B', 'D']
 
        if 0 < len(stack):
            # 'D'
            data = stack.pop()
            result += data
            index = tree.index(data)
            if tree[2*index + 2] != '.':
                stack.append(tree[2*index + 2])
                start_index = 2*index + 2
        else:
            break
    print(result) # DBAECFG  (왼쪽 자식) (루트) (오른쪽 자식)
 
 
 
def postorder(tree):
    stack = []
    result = ''
    start_index = 0
    stack.append(tree[start_index])
 
    while True:
        # 왼쪽 자식 체크
        while tree[2 * start_index + 1] != '.':
            if tree[2 * start_index + 1] not in result:
                stack.append(tree[2 * start_index + 1])
                start_index = 2*start_index + 1
            else:
                break
 
        # 오른쪽 자식이 존재하는지를 먼저 체크하기 위해 pop() 하지 않는다
        last_data = stack[-1]
        index = tree.index(last_data)
 
        # 오른쪽 자식이 존재하는지 체크
        if tree[2*index + 2] == '.':
            # 오른쪽 자식이 없으면 그냥 출력
            result += stack.pop()
            start_index = index
        else:
            # 오른쪽 자식이 있으면 다음의 규칙대로 해결
            #
            # 오른쪽 자식이 아직 나오지 않은 노드 -> stack에 추가
            if tree[2 * index + 2] not in result:
                stack.append(tree[2 * index + 2])
                start_index = 2 * index + 2
            else:
                # 오른쪽 자식이 이미 나온 노드 -> 현재의 노드를 출력하고 start_index를 stack에 들어있는 노드로 바꿔준다.
                result += stack.pop()
                if 0 < len(stack):
                    data = stack[-1]
                    start_index = tree.index(data)
                else:
                    break
 
    print(result) # DBEGFCA (왼쪽 자식) (오른쪽 자식) (루트)
 
 
def solve(tree):
    preorder(tree) # ABDCEFG
    inorder(tree) # DBAECFG
    postorder(tree) # DBEGFCA (왼쪽 자식) (오른쪽 자식) (루트)
 
 
 
if __name__ == "__main__":
    n = int(input().strip())
    tree = ['.']* int(math.pow(2, n))
    for i in range(n):
        info = input().strip().split(' ')
        if tree[0] == '.':
            tree[0], tree[1], tree[2] = info[0], info[1], info[2]
            continue
 
        root = info[0]
        idx = tree.index(str(root))
        tree[2*idx + 1] = info[1]
        tree[2*idx + 2] = info[2]
    tree = ''.join(tree)
    solve(tree)
Colored by Color Scripter

cs

UDP (User Datagram Protocol)

다임하게 — Thu, 23 May 2019 21:30:36 +0900

UDP (User Datagram Protocol)

Client와 Server가 서로 데이터를 주고 받을때 우리는 네트워크상의 수많은 약속(프로토콜)들을 지켜가면서 통신을 하고 있다. 우리가 주고 받는 데이터(패킷)들은 한번에 목적지로 가는 것이 아니라 우리가 잘 알고 있는 인터넷 5계층이나 OSI 7계층을 통과하여 전달된다. 이 포스팅에서는 전송 계층에서 사용하는 대표적인 프로토콜인 UDP에 대해서 알아보고자 한다.

계층별 주요 프로토콜 (키워드)

UDP(User Datagram Protocol)

UDP(User Datagram Protocol)는 TCP와 함께 대표적인 전송 계층의 프로토콜이다. UDP의 특징은 TCP처럼 다양한 기능이 있는 것이 아니라 많은 기능을 과감히 생략한 단순함에 있다. UDP의 전송 방식은 너무 단순해서 서비스의 신뢰성이 낮고, 데이터그램 도착 순서가 바뀌거나, 중복되거나, 심지어 통보 없이 누락시키기도 한다. 따라서 UDP는 일반적으로 오류의 검사와 수정이 필요 없는 애플리케이션에서 사용한다고 본다.

패킷과 데이터그램 : 이 둘을 혼용해서 쓰기도 하지만 '패킷'은 일반적인 데이터 덩어리를 지칭한다면, '데이터그램'은 데이터를 전송하는 방식이 불안정하고 전송 실패에 대한 노티피케이션(notification)도 없는, 즉 신뢰할 수 없는 서비스를 통해 전달되는 패킷을 지칭한다. 따라서 UDP 패킷은 패킷보다는 데이터그램이라고 지칭하는 것이 옳다.

UDP의 사용

도메인 이름 서비스(DNS)
IPTV(와 이와 같은 스트리밍 미디어 서비스)
음성 인터넷 프로토콜(VoIP)
TFTP, RTSP, RIP, OSPF
NTP(Network Time Protocol)
IP 터널
많은 온라인 게임 (UDP가 multicast를 지원하므로 가능)

UDP는 브라우저와 인터넷 애플리케이션이 의존하고 있는 도메인 네임 시스템(DNS)에서 사용된다. 브라우저가 데이터 교환을 위해서는 DNS를 통해 컴퓨터의 IP 주소를 알아내야만 하는데, 인터넷에서 매번 요청하는 DNS 서비스에서 UDP에 의존하여 데이터를 전송하고 있었음에도,(물론 TCP라는 신뢰할 수 있는 전송 프로토콜이 있었기 때문이기도 하지만) 웹페이지나 웹 애플리케이션이 UDP를 데이터 전송 수단으로 잘 사용하지 않았었다. 최근 WebRTC(Web Real-Time Communication)가 등장하면서 UDP를 이용해 브라우저 내에서도 음성 통화나 화상 통화, 또는 P2P 통신과 같은 실시간 커뮤니케이션이 가능하게 되었고UDP도 이제 통용되는 브라우저 전송 수단이 되어 가고 있다.

UDP가 Null 프로토콜이라고 불리는 이유

UDP는 NULL 프로토콜이라고도 불린다. 그 이유는 무엇일까. 아래의 UDP 헤더의 구조를 살펴보면 총 8bytes(1bytes = 8bit)로 간단하게 구성되어 있다. 그런데 그마저도 발신지 포트와 체크섬 필드 모두 UDP에서는 선택 입력 필드이다. 아래에서 UDP의 특징에 대해 알아보겠지만 UDP는 네트워크의 혼잡 처리라던가, 패킷 손실에 대한 어떠한 처리도 하지 않는다. UDP가 하는 일이라곤 IP 위 계층에서 통신 호스트의 발신, 수신 애플리케이션 포트를 내장하여 '애플리케이션 다중처리'에 이용하는 것뿐이며, 모든 에러 탐지와 에러 복구가 그 위 계층 애플리케이션에서 이루어진다. 결국 프로토콜치고는 너무 하는 일이 없어서 Null 프로토콜이라고 부르는 것이다.

8Bytes( 출발지 포트, 도착지 포트, 길이, 체크섬 각각 16bits(2bytes)), https://en.wikipedia.org/wiki/User_Datagram_Protocol(wiki)

UDP의 특징

메시지를 무사히 운반할 수 있다는 보장이 없음 (응답(Ack), 재전송, 타임아웃 없음)
메시지를 순서대로 운반할 수 없음 (패킷, 시퀀스 넘버, 재정렬, head-of-line(HOL) 블로킹 없음
커넥션 상태 트래킹 없음 (커넥션 성립 혹은 종료 매커니즘 없음)
혼잡 제어 없음 (내장된 클라이언트나 네트워크 피드백 메커니즘 없음)

TCP 와 UDP 헤더 구조 비교

UDP 헤더와 TCP 헤더를 비교해보자. UDP 프로토콜은 발신지 포트, 수신지 포트, 패킷의 길이와 체크섬이라는 네 필드로 구성되어 있다. 즉 IP가 패킷을 수신지 호스트로 운반하면, 호스트는 UDP 패킷을 열고 수신지 포트에서 타깃 애플리케이션을 찾아내 메시지를 전달할 수 있다는 뜻이다. 앞서 말한 것처럼 UDP의 헤더에서 출발지 포트와 체크섬은 애플리케이션이 생략될 수 있다.

UDP header, 8Bytes( 출발지 포트, 도착지 포트, 길이, 체크섬 각각 16bits(2bytes)), https://en.wikipedia.org/wiki/User_Datagram_Protocol (wiki)

TCP header, https://en.wikipedia.org/wiki/Transmission_Control_Protocol (wiki)

UDP와 TCP의 비교

Transmission Control Protocol is a connection-oriented protocol(연결형 프로토콜), which means that it requires handshaking to set up end-to-end-communications.

User Datagram Protocol is a simpler message based connectionless and unreliable protocol(비연결형 프로토콜).

TCP는 데이터를 주고 받을 양단 간에 먼저 연결(3-way handshaking)을 설정하고 양방향으로 데이터를 전송하지만, UDP는 따로 연결하지 않고 수신자가 데이터를 받을 준비를 확인하는 단계 없이 단방향으로 정보를 전송한다. TCP는 메시지의 수신을 확인하고 패킷이 유실되거나 수신지로부터 응답이 없을 경우에 데이터를 재전송하지만, UDP는 수신자가 메시지를 수신했는지 확인하지 않으며 따라서 데이터를 재전송하는 일이 없다. TCP에서는 메시지가 보내진 순서를 보장하기 위해서 해당 순서가 아닌 패킷의 경우 TCP 버퍼에 넣어 대기시킨 다음 순서에 맞는 패킷이 왔을 때 재조립하지만, UDP는 메시지 도착 순서를 예측할 수 없다.

TCP는 바이트 스트림 위주의 프로토콜이기 때문에 애플리케이션 메시지의 시작과 끝의 범위를 명시하지 않고 여러 패킷에 걸쳐 전송할 수 있다. 이를 위해 TCP에서는 커넥션의 양쪽 끝에 커넥션 상태를 지정하고 각 패킷에 전송번호를 부여해서, 패킷이 소실되었을 경우 패킷을 해당 순서에 따라 재전송 한다. 반면 UDP 데이터그램은 그 범위가 명확하다. 데이터그램 메시지 하나는 IP 패킷 하나에 완전히 포함되기 때문에, 애플리케이션이 패킷을 하나 읽을 때마다 메시지 전체가 수신된다. 데이터 그램은 TCP에서처럼 조각난(fragmented) 상태로 운반되는 경우는 없다.

UDP는 상태를 유지하지 않는 간단한 프로토콜이며, 다른 애플리케이션 포로토콜을 호출하여 작동시키는 데에 적절하다. 따라서 TCP보다 UDP의 속도가 일반적으로 빠르고 오버헤드가 적다. UDP는 사실상 거의 모든 프로토콜 동작에 관한 디자인 결정 사항을 위 계층의 애플리케이션에 위임했다고 볼 수 있다. UDP는 멀티캐스팅이 지원되어 단일 데이터그램 패킷이 매우 많은 사용자들에게 중복 없이 자동으로 라우팅 될 수 있다.

TCP(Trnsmisson Control Protocol)

인터넷 환경에서 기본으로 사용하는 연결형 서비스를 지원하는 전송 계층 프로토콜이다. 호스트 간 신뢰성 있는 데이터 전달과 흐름제어 및 혼잡 제어 등의 기능을 제공한다.

특징

가상 회선 연결 방식, 연결형 서비스를 제공
높은 신뢰성 (Sequence Number, Ack Number를 통한 신뢰성 보장)
연결의 설정(3-way handshaking)과 해제(4-way handshaking)
데이터의 순서가 지켜짐
데이터 흐름 제어(수신자 버퍼 오버플로우 방지) 및 혼잡 제어(네트워크 내 패킷 수가 과도하게 증가하는 현상 방지)
전이중(Full-Duplex), 점대점(Point to Point) 서비스
데이터의 경계를 구분 안함

UDP (User Datagram Protocol)

비연결형 서비스를 지원하는 전송계층 프로토콜이다. 인터넷상에서 서로 정보를 주고받을 때 정보를 보내고 응답을 받지 않고 보내는 쪽에서 일방적으로 데이터를 전달하는 통신 프로토콜이다. 보내는 쪽에서는 받는 쪽이 데이터를 받았는지 받지 않았는지 확인할 수 없고, 또 확인할 필요도 없도록 만들어졌다.

특징

비연결형 (port만 확인하여 소켓을 식별하고 송수신, TCP의 hadnshaking 같은 연결 설정이 없음)
비신뢰성
패킷 오버헤드가 적어 네트워크 부하 감소 (전송 속도가 빠름)
데이터의 전송 순서가 바뀔 수 있음
오류검출 (헤더에 오류 검출 필드를 포함하여 무결성 검사)
데이터의 경계를 구분함
데이터의 정소 순서가 바뀔 수 있음
DNS, NFS, SNMP, RIP 등 사용

UDP와 네트워크 주소 변환기(NAT : Network Address translation)

NAT 도입 배경

IPv4의 주소의 길이, 주소 범위, 최대 고유 IP수

IPv4 주소의 길이는 32비트이므로, 제공할 수 있는 최대 고유 IP 수는 약 42억개 정도다. 90년대 초에 인터넷 호스트 수가 기하급수적으로 증가하면서, 모든 호스트에게 고유 IP 주소를 할당할 수 없음이 명백했다. 한정된 Public IP 주소의 고갈 문제를 해결하기 위해 1994년 중반에 제안되어 임시로 도입했던 방법이 바로 네트워크 주소 변환기 NAT(Network Address translation) 이다.

NAT(Network Address Traslation)란

IP 네트워크 주소 변환기 (NAT)

NAT는 내부 네트워크에서 외부 네트워크로 통신을 할 때 IP를 변환하는 기술이다. 변환기 뒤에 있는 로컬 IP 주소 공간을 다른 네트워크가 재사용할 수 있게 하여 주소 부족 문제를 해결한다. 네트워크 끝에 NAT 기기를 설치해서, Private IP와 Port Number를 한 개 이상의 Public IP와 Port Number와 짝지어 관리한다. Private IP는 공유기에서 발급한 IP 주소이므로 외부에서는 이 Private IP로 바로 접근 할 수 없다. 외부에서는 Public IP와 Port Number를 통해 요청하고 위에 그림에서 보는 것처럼 NAT table에서 Public IP, Port Number와 짝을 이루는 Private IP, Port Number를 찾아 주소를 변환시키고 해당 주소로 패킷을 전달해준다.(private에서 public으로 요청할 때도 NAT table을 통해 변환한다).

* 같은 Private 네트워크에 존재하는 컴퓨터일 경우에는 같은 네트워크 안에 있기 때문에 NAT 없이 Private IP만으로도 통신이 가능하다.

NAT를 이용하는 목적 (필요성)

한정된 공인 IP 부족 문제 해결
외부로부터 내부방 보호

NAT를 이용하면 한정된 인터넷의 Public IP를 다수가 함께 사용함으로써 절약할 수 있다. 내부망에서는 Private(사설) IP를 사용하여 통신을 하고, 외부망과의 통신시에는 NAT를 거쳐 Public IP로 자동 변환된다. 공개된 인터넷망과 사설망 사이에 방화멱을 설치하여 외부 공격으로부터 내부 사용자들을 보호할 수 있다.

NAT는 앞서 말한 것처럼 임시로 도입된 방법이었다. 하지만 많은 기업들과 홈 프록시, 라우터, 보안기기, 방화벽, 그 밖의 수많은 하드웨어와 소프트웨어 기기들에게 보편적인 요소로 자리 잡았고, NAT 미들 장비는 더 이상 임시방편이 아니라, 인터넷 인프라에 없어서는 안 될 부분이 되었다.

NAT와 UDP 사이에 발생하는 문제들

Stateless한 UDP와 커넥션 상태에 따라 작동하는 NAT 간의 문제

UDP에서 NAT 변환 작업을 할 때 가장 큰 문제는 데이터 운반을 위해 라우팅 테이블을 관리해야 한다는 사실이다. 기본적으로 NAT 미들 장비는 커넥션 상태에 따라 작동하는데, 알다시피 (TCP처럼 연결을 위해 handshaking 하거나 연결 종료 절차가 있는게 아니라서) UDP는 커넥션(연결) 상태 정보를 가지고 있지 않다. 따라서 UDP의 데이터그램을 전송하려면 변환기가 상태가 없는 UDP의 흐름 상태를 알고 있어야 한다. 뿐만 아니라 변환기는 변환 레코드를 언제 버려야 하는지도 결정해야 한다. UDP는 커넥션 종료 시퀀스가 없어서 피어가 통보 없이 언제든 데이터그램 전송을 멈출 수 있다. 그래서 변환기는 UDP 라우팅 레코드를 일정 시간이 지나면 자동으로 폐기하는 방법을 사용한다. 결국 UDP에서 장기 세션을 유지하는 가장 좋은 방법은 양방향 킵-얼라이브 패킷을 도입하여 정기적으로 모든 NAT 기기의 변환 레코드 타이머를 리셋하는 것이다(타이머가 다되면 폐기될테니 킵-얼라이브 패킷을 보내 타이머를 다시 리셋해주는 것이다).

NAT와 TCP : TCP 프로토콜은 잘 정의된 핸드셰이크와 연결 종료 시퀀스를 따르기 때문에 변환 레코드를 언제 생성하고 지워야 하는지 적절한 시점에 신호를 준다. 하지만 실제로는 많은 NAT 기기가 TCP와 UDP 세션 모두에 비슷한 타임아웃 로직을 적용하고 있다. 결과적으로 TCP도 양방향 킵얼라이브 패킷이 필요한 경우가 생기는 것이다.

많은 애플리케이션이 UDP 커넥션 자체를 생성할 수 없다는 문제

많은 애플리케이션이 UDP 커넥션 자체를 생성할 수 없다는 문제가 있다. 내부 네트워크에서 상호작영을 시작하면서 변환을 수행하는 클라이언트 애플리케이션에게는 NAT의 동작 방식이 크게 문제되지는 않지만, VoIP, 게임 혹은 파일 공유 등 P2P 애플리케이션에서 이 문제가 발생한다. P2P는 애플리케이션이 서버와 클라이언트의 역할을 모두 수행해야만 양방향 커뮤니케이션이 가능한데 NAT가 존재하면 여러 문제가 발생한다. UDP와 NET의 어떤 점이 문제를 발생하게 할까.

문제 1. NAT 안쪽에 위치한 내부 클라이언트는 Private IP만 알고 자신의 Public IP를 모른다. 데이터 내부에서 자신의 Private IP를 쓴 경우에는 커넥션은 실패하게 된다. NET table을 사용한 완벽한 변환이 불가능할 수도 있다는 의미이다.

문제 2.외부에서 패킷이 도착하더라도 패킷에 목적지 Port number가 올바르게 명시되어 있어야 하고, NAT 테이블에 해당 Port number가 존재하지 않으면 Private IP에 전달되지 않고 소실된다. (매핑 데이터가 없어 인바운드 패킷이 소실됨)

NAT 기기는 Public IP 내부의 경로를 자동으로 파악할 수 없다 (Private IP와 Port number를 다 알고 있는게 아니라는 의미, 사설망을 설치할 때 미리 NET table을 생성해주는 것 같다). NAT 기기는 단순히 Net table에 있는 (Public IP, port)와 매칭되는 (Private IP, port)로 변환시켜 패킷을 전송해주는, 패킷 필터링 역할만 수행한다. 따라서 Net table에 port가 제대로 명시되어 있지 않으면 그냥 패킷을 버려버린다.

위의 문제를 해결하기 위해서 STUN, UTRN, ICE와 같은 프로토콜들이 존재하며, 실제로 이러한 프로토콜들을 결합하여 사용한다.

UDP를 보완하기 위한 프로토콜 - STUN, UTRN 그리고 ICE

STUN (Sesson Traversal Utilities for NAT)

STUN 서버에 요청해 Public IP, Port 반환하기

STUN은 호스트 애플리케이션이 네트워크상의 NAT 기기를 발견하고 현재의 커넥션에 지정된 Public IP와 Port number를 알아낼 수 있게 하는 프로토콜이다. 이 프로토콜이 올바르게 동작하려면 공용 네트워크상에서 잘 알려진 제3의 STUN 서버의 도움을 받아야 한다. DNS 검색을 통해, 혹은 주소를 직접 지정해서 STUN 서버의 주소를 알아내자. STUN 서버에게 바인딩 요청을 보내면 현재의 Private IP, port의 Public IP, Port를 받을 수 있다. 이 프로토콜을 사용함으로써,

애플리케이션이 자신의 Public IP, port number를 얻을 수 있다.
STUN 서버에게 아웃바운드 바인딩 요청을 보낼 때, NAT table에 라우팅 값이 입력되므로 인바운드 패킷은 NET table에 해당 값이 없을 걱정 없이 Private IP에 데이터를 전달할 수 있다.
STUN 프로토콜이 킵-얼라이브 핑 역할을 해서 NAT 라우팅 타이머가 만기되어 table이 리셋되는 것을 막는다.

그러나 실제로는 STUN만으로는 모든 NAT 토폴로지와 네트워크 설정을 감당할 수 없다. UDP가 방화벽이나 다른 네트워크 기기에 의해 아예 막혀버릴 수도 있기 때문인데 TURN이 실패하였을 때의 대비책으로 TURN 프로토콜을 사용한다.

TURN(Traversal Using Relays around NAT)

TURN 프로토콜은 모든 것이 실패했을 때, UDP를 버리고 TCP로 전환(TURN)하는 기능을 한다. TURN은 'Relays(중계)'라는 개념이 매우 중요하다. TURN은 피어 간에 데이터를 왕복 운반하는 공용 중계(public relay)를 이용한다. 방법은 다음과 같다. 양쪽 클라이언트 모두 같은 TURN 서버에 할당 요청을 보내 커넥션을 시작한 후 권한 협상을 한다.협상이 완료되면 양쪽 호스트가 TURN 서버에 데이터를 보내고 TURN은 데이터 전달을 중계해줌으로써 서로 통신할 수 있게 해준다.

이 방식은 두 피어를 연결해주는 안정적인 방법이지만 더이상 P2P 통신이라고 할 수 없다. 또한 TURN 서버가 두 피어의 요청을 받아 중계해야 하기 때문에(양방향 중계) 상당한 부하를 받게 된다. 따라서 TURN은 다른 모든 연결이 실패했을 때의 대비책으로 사용하는게 바람직하다.

ICE(Interactive Connectivity Establishment)

ICE는 네트워크 참여자 간에 가장 효율적인 터널을 찾을 수 있는 프로토콜이다. ICE는 우선 연결 가능한 접속 경로들을 수집 한 후, 해당 경로에 패킷을 송수신 해서 각 경로에서 가장 품질이 우수한 것을 사용한다. ICE를 이용하면 직접 연결이 가능한 곳에서는 직접 연결을 수행하고, 직접 연결이 어려운 경우에는 STUN을 활용하고, 다른 모든 옵션이 실패했을 때는 TURN을 사용한다. 실제로 UDP 기반의 P2P 애플리케이션을 개발할 때에는 ICE, STUN, TURN을 모두 활용한 플랫폼 API, 혹은 제 3 라이브러리를 사용하는게 편리하다.

참고

참고 사이트

참고 도서

구글 엔지니어에게 듣는 네트워킹과 웹 성능 최적화 기법

Python으로 푸는 프로그래머스 캐시((2017년)KAKAO BLIND RECRUITMENT)

다임하게 — Sat, 18 May 2019 11:00:06 +0900

캐시

2017 카카오 블라인드 채용에 나왔던 문제이다.

제이지가 DB 캐시를 적용하여 데이터베이스에서 게시물을 가져오는 부분의 성능 개선을 하고 있을 때, 캐시 크기를 얼마로 해야 효율적인지 알아낼 수 있도록 코드를 짜야한다. DB 캐시를 적용할 때 캐시 크기에 따른 실행 시간 측정 프로그램을 작성하시오.

프로그래머스에서 문제보기

문제 풀이

solution.
1. 큐로 사용할 리스트를 선언한다(dictionary에는 우선순위를 표현할 index가 없으므로 큐를 사용했다)
2. cities에 담긴 값을 하나씩 꺼내어, queue에 이미 그 값이 있는지 없는지를 확인한다.
3. 이때 대소문자 구분 없도록 '단어'.lower() 할수를 사용하여 모두 소문자로 바꿔준다.
4. index 값이 작을 수록 사용한지 오래된 도시명이며,
index 값이 클 수록 최신이거나 hit가 일어난 도시명이다.
5. 큐에 city가 있으면 (캐시 히트)
해당 도시를 맨 뒤로 옮겨준다
6. 큐에 city가 없으면, (캐시 미스)
큐(캐시)가 꽉 차 있으면 맨 앞 도시를 pop해주고 맨뒤에 새로운 도시를 넣어준다.
큐(캐시)의 크기가 0 이상일 경우에만 큐에 넣어준다.
7. 캐시히트가 일어나면 answer에 1을 더하고,
캐시미스가 일어나면 answer에 5를 더하여 최종적으로 그 값을 반환한다.

파이썬 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

def solution(cacheSize, cities):
    queue = [] # use an ordered container
    answer = 0
    for c in cities:
        city = c.lower()
        if city in queue:
            # cache hit
            index = queue.index(city)
            queue.pop(index)
            queue.append(city)
            answer += 1
        else:
            
            # cache miss
            if cacheSize and len(queue) >= cacheSize:
                queue.pop(0)
                queue.append(city)
            else:
                if cacheSize > 0:
                    queue.append(city)
            answer += 5
    print(answer)
 
if __name__ == "__main__":
    solution(3, ['Jeju', 'Pangyo', 'Seoul', 'NewYork', 'LA', 'Jeju', 'Pangyo', 'Seoul', 'NewYork', 'LA'])  # 50
    solution(3, ['Jeju', 'Pangyo', 'Seoul', 'Jeju', 'Pangyo', 'Seoul', 'Jeju', 'Pangyo', 'Seoul']) # 21
    solution(2, ['Jeju', 'Pangyo', 'Seoul', 'NewYork', 'LA', 'SanFrancisco', 'Seoul', 'Rome', 'Paris', 'Jeju', 'NewYork', 'Rome']) # 60
    solution(5, ['Jeju', 'Pangyo', 'Seoul', 'NewYork', 'LA', 'SanFrancisco', 'Seoul', 'Rome', 'Paris', 'Jeju', 'NewYork', 'Rome']) # 52
    solution(2, ['Jeju', 'Pangyo', 'NewYork', 'newyork']) # 16
    solution(0, ['Jeju', 'Pangyo', 'Seoul', 'NewYork', 'LA']) # 25
Colored by Color Scripter

cs

Python에서 로그를 남기는 방법

다임하게 — Fri, 17 May 2019 21:00:47 +0900

이 포스팅은 Python의 기본적인 logging 방법에 대해서 이해하기 위해 작성되었다. 이 포스팅의 최종 목표는 개발자가 로그를 어떻게 작성하는 것이 로그를 잘 활용할 수 있는지에 대한 방법을 알아보는 것이다. 몇개의 포스트로 나눠 작성될지 모르겠으나 연속된 포스팅이 불가능할 수도 있으므로, Logging과 관련된 링크는 아래에 추가하는 것으로 대신하도록 하겠다.

Logging이란 무엇인가

개발자가 시스템을 24시간 들여다보고 있을 순 없을 뿐더러 시스템이 오류 없이 항상 완벽게 동작할거라 보장할 수는 없다. 즉, 언제 어느 때든 예상하지 못한 시스템의 오류가 발생할 수 있고 이를 위한 후속 조치가 이뤄질 수 있도록 해야한다는 의미이다. 개발자가 오류를 고치기 위해서는, 에러가 발생하였을 당시의 시스템의 상황을 알 수 있어야 하는데 그러한 데이터를 남길 수 있도록 언어에서 지원하고 있는 기능이 바로 Logging이다. 파이썬에서는 개발자가 Logging을 남길 수 있도록 강력한 표준 라이브러리 logging을 제공하고 있다. 로깅을 활용한다면 오류를 해결할 뿐만 아니라 다음과 같은 방법으로도 데이터를 활용 할 수 있다는 장점이 있다.

버그를 발견하고 처리하기 위한 데이터 제공
경우에 따라 어플리케이션 내에 접근한 사용자의 IP 데이터 등을 텍스트 형태로 간편하게 기록
개발자가 시스템 흐름을 이해하기 쉬움
어플리케이션의 성능을 향상(scaling)하기 위한 계획이나, 마케팅을 위한 패턴을 분석하는 용도로 활용

기본적인 Logging 사용 방법

파이썬의 logging 모듈에서 제공하는 기본 기능은 초보자부터 기업에서 사용할 수 있을 만큼 강력하다. 기본적으로 logging에는 이벤트의 심각도(level)을 5가지로 나누고 잇으며, 각각에는 해당 심각도 수준의 이벤트를 기록하는데 사용할 수 있는 해당 메소드가 있다. 정의된 심각도는 순서대로 다음과 같다.

DEBUG
INFO
WARNING
ERROR
CRITICAL

1
2
3
4
5
6

import logging
 
logging.info('info test')
logging.debug('debug test')
logging.warning('warning test')
logging.error('error test')

cs

터미널에서 실행시켜보면 warning과 error 레벨의 경우에만 출력된다.

참고

Logging in python

Python의 decorator로 log 남기기

다임하게 — Fri, 17 May 2019 18:00:31 +0900

Python으로 프로젝트를 진행하면서, API 요청에 대한 Request, Response에 대한 info를 로그(log)로 남기고 싶다면 decorator를 사용한다면 편리하다.

decorator란

함수를 감싸고 있는 함수라고 생각하면 된다. @를 사용하여 wrapping 하고 싶은 함수 위에 적어주면, python의 모든 객체는 1급 객체이므로 해당 함수가 데코레이터의 인자로 전달될 수 있다. 이때 클로저(내부 함수가 외부 함수의 인자를 기억하고 있는 것)라는 개념을 이해하고 있어야 하는데, 데코레이터의 인자로 전달된 함수는 외부에서 전달되었음에도 외부 함수의 인자값들을 모두 기억하고 있다. 아래의 logger_decorator_with_params 메소드는 decorator로 활용되었다. 해당 함수를 실행하기 전, 후에 대해서 어떠한 작업을 해야할 필요가 있는 경우에 활용하면 좋다.

decorator의 활용

데코레이터는 다음과 같은 경우에 활용된다.

log를 남겨야 하는 경우
프로그램 성능을 위한 테스트 목적
경우에 따라서 exception handling을 위해서 활용

하기도 하는 것 같다. 내 프로젝트에는 log를 남기기 위해서 아래와 같이 decorator를 구현하였다.

파이썬 코드 - decorator 메소드 logger_decorator_with_params 구현

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

import os
import studi
import logging
from flask import request
 
def gen_logger(module_name):
    logger = logging.getLogger(module_name)
    logger.setLevel(logging.DEBUG)
    logger_handler = logging.FileHandler(os.path.join(studi.app.config['LOG_DIR'], module_name + '.log'))
    logger_handler.setLevel(logging.DEBUG)
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    logger_handler.setFormatter(formatter)
    logger.addHandler(logger_handler)
    return logger
 
 
def logger_decorator_with_params(logger):
    def wrapper(func):
        def decorator(*args, **kwargs):
            logger.info('REQUEST, {0}, params : {1}'.format(request.environ['werkzeug.request'], kwargs))
            result = func(*args, **kwargs)
            logger.info("RESPONSE, {0}".format(result))
            return result
        return decorator
    return wrapper
 
logger = gen_logger('studi')
Colored by Color Scripter

cs

파이썬 코드 - decorator로 활용된 logger_decorator_with_params()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

 
class Note(Resource):
 
    def __init__(self):
        pass
 
    @log.logger_decorator_with_params(log.logger)
    def get(self):
        try:
            result = sqlalchemy_orm.get_all_data_from_db(sqlalchemy_orm.Notes)
        except sqlalchemy.exc.SQLAlchemyError:
            error_message = util.traceback_custom_error()
            response = custom_error.SQLAlchemyError(error_message).to_dict()
            return response, 500
        except:
            error_message = util.traceback_custom_error()
            response = custom_error.UnExpectedError(error_message).to_dict()
            return response, 500
        else:
            if result:
                return {'notes' : result}, 200
            return {'notes': []}, 201
Colored by Color Scripter

cs

Python으로 푸는 LeetCode 506. Relative Ranks (Easy)

다임하게 — Thu, 16 May 2019 23:30:50 +0900

LeetCode 506. Relative Ranks

점수가 가장 높은 순서대로 3명에게는 메달을 수여하고, 그 외에는 순위를 구한 값이 담긴 리스트를 반환한다.

문제 풀이

nums를 역순으로 정렬한 리스트 sorted_nums를 생성한다. sorted_nums에서부터 값을 하나씩 꺼내게 되면 해당 점수의 순위를 알 수 있다. index 2까지의 점수는 순위가 아닌 medal을 받아야 한다. 따라서 medal 리스트로부터 index를 활용해 어떤 메달을 받게 될지 구한다. 그 외에는 index + 1 한 값이 순위이므로 그 값을 nums에 추가시킨다.

파이썬 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class Solution:
    def findRelativeRanks(self, nums):
        sorted_nums = sorted(nums, reverse=True)
        medal = ["Gold Medal", "Silver Medal", "Bronze Medal"]
        # result = [0]*len(sorted_nums)
        i = -1
        for n in sorted_nums:
            i += 1
            idx = nums.index(n)
            if i < 3:
                nums[idx] = medal[i]
                continue
            nums[idx] = str(i + 1)
        return nums
Colored by Color Scripter

cs

Python으로 푸는 LeetCode 744. Find Smallest Letter Greater Than Target (Easy)

다임하게 — Wed, 15 May 2019 23:30:29 +0900

주어진 문자보다 가장 처음으로 큰 숫자를 찾아 반환하는 코드를 짜시오