코낙의 코딩일기

파이썬으로 풀어보는 백준 2912번: 백설공주와 난쟁이

코딩하는 낙타 — Fri, 22 May 2020 22:23:25 +0900

https://www.acmicpc.net/problem/2912

2912번: 백설공주와 난쟁이

문제 백설 공주와 난쟁이 N명과 함께 숲 속에 살고 있다. 난쟁이는 매일 광산에 일하러가고, 백설 공주는 그동안 페이스북을 하고 있다. 매일 아침 난쟁이는 한 줄로 휘파람을 불면서 광산으로 ��

www.acmicpc.net

내 풀이(1):

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 copy
import sys
input = sys.stdin.readline
N, C = map(int, input().split())
data = list(map(int, input().split()))
M = int(input())
 
record = [0] * (N+1)
record[0] = {}
rec = {}
for idx, d in enumerate(data):
    if d in rec:
        rec[d] += 1
    else:
        rec[d] = 1
    record[idx + 1] = copy.deepcopy(rec)
 
for _ in range(M):
    A, B = map(int, input().split())
    for num in record[B]:
        if num in record[A-1]:
            num_A = record[A-1][num]
        else:
            num_A = 0
        num_B = record[B][num]
        if num_B - num_A > (B-A+1) / 2:
            print('yes', num)
            break
    else:
        print('no')

 

python3, 시간 초과

처음으로 시도한 방법은 각 단계까지의 모자 색깔에 대한 기록을 딕셔너리의 형태로 각각 남기는 것이었다. 각 단계에 서로 다른 딕셔너리를 남겨야 하기 때문에 deepcopy를 이용해주었고 deepcopy 과정에서 원소의 개수만큼의 시간을 소요하게 된다. 또한 A, B라는 두 단계가 선택되면 두 단계에 대한 특정 색깔의 차이를 계산할 때 최대 10000가지 색에 대해 검토하게 된다. deepcopy 과정과 10000가지 색에 대한 검토에 의해 시간 초과가 난 것으로 판단된다.

내 풀이(2):

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

import sys
input = sys.stdin.readline
 
def cal(start, end, idx, A, B):
    if A <= start and end <= B:
        for num in segmentTree[idx]:
            if num in result:
                result[num] += segmentTree[idx][num]
            else:
                result[num] = segmentTree[idx][num]
        return
 
    if end < A or B < start:
        return
 
    mid = (start + end) // 2
    cal(start, mid, idx * 2, A, B)
    cal(mid + 1, end, idx * 2 + 1, A, B)
    return
 
 
def make(start, end, idx):
    record = {}
    if start == end:
        record[data[start - 1]] = 1
        segmentTree[idx] = record
        return record
 
    mid = (start + end) // 2
    left = make(start, mid, idx * 2)
    right = make(mid + 1, end, idx * 2 + 1)
 
    for num in left:
        if num in record:
            record[num] += left[num]
        else:
            record[num] = left[num]
 
    for num in right:
        if num in record:
            record[num] += right[num]
        else:
            record[num] = right[num]
 
    segmentTree[idx] = record
    return record
 
 
N, C = map(int, input().split())
data = list(map(int, input().split()))
M = int(input())
segmentTree = [{} for _ in range(1048562)]
make(1, N, 1)
for _ in range(M):
    A, B = map(int, input().split())
    result = {}
    cal(1, N, 1, A, B)
    check = (B - A + 1) // 2
    for num in result:
        if result[num] > check:
            print('yes', num)
            break
    else:
        print('no')

 

python3, 시간 초과
구간합을 구하는 문제라는 데에서 착안하여 segment tree를 만들어 이용해보았다. 세그먼트 트리는 구간에 대한 정보를 저장하는 데 사용하는 트리 데이터 구조로써 구간 탐색에 드는 시간을 O(N)에서 O(logN)으로 줄여준다. 보든 세그먼트 트리는 구간합을 저장하고 불러올 때 매우 유리한데 위 문제에서는 딕셔너리의 형태로 최대 10000개의 색에 대한 키와 값을 저장해 야하기 때문에 세그먼트 트리를 만드는데 드는 시간이 다소 소요되는 편이다. 이후 세그먼트 트리를 이용하여 10000가지 색에 대해 과반수를 넘는지 판단하여 문제를 해결하였으나 이 방법 역시 시간 초과에 걸리고 말았다.
 
 
내 풀이(3):

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

import sys
import random
 
input = sys.stdin.readline
def cal(start, end, idx, A, B, num):
    if A <= start and end <= B:
        if num in segmentTree[idx]:
            return segmentTree[idx][num]
        else:
            return 0
 
    if end < A or B < start:
        return 0
 
    res = 0
    mid = (start + end) // 2
    res += cal(start, mid, idx * 2, A, B, num)
    res += cal(mid + 1, end, idx * 2 + 1, A, B, num)
    return res
 
 
def make(start, end, idx):
    record = {}
    if start == end:
        record[data[start - 1]] = 1
        segmentTree[idx] = record
        return record
 
    mid = (start + end) // 2
    left = make(start, mid, idx * 2)
    right = make(mid + 1, end, idx * 2 + 1)
 
    for num in left:
        if num in record:
            record[num] += left[num]
        else:
            record[num] = left[num]
 
    for num in right:
        if num in record:
            record[num] += right[num]
        else:
            record[num] = right[num]
 
    segmentTree[idx] = record
    return record
 
 
N, C = map(int, input().split())
data = list(map(int, input().split()))
M = int(input())
segmentTree = [{} for _ in range(1050000)]
make(1, N, 1)
for _ in range(M):
    A, B = map(int, input().split())
    check = (B - A + 1) // 2
 
    check_color = {}
    for _ in range(20):
        random_color = data[random.randint(A, B)-1]
        if random_color in check_color:
            continue
        else:
            check_color[random_color] = 1
        if cal(1, N, 1, A, B, random_color) > check:
            print('yes', random_color)
            break
    else:
        print('no')

 

python3, 4136ms

10000가지나 되는 색상에 대해 모두 조사해보는 것은 많은 시간을 요구한다. 때문에 여기서 수학적, 확률적 접근이 이용된다. 특정 구간에 과반 수 이상의 특정 색깔이 존재한다고 가정하면 임의로 한 명의 난쟁이를 뽑아 모자 색을 확인했을 때, 그 색이 과반수가 아닐 확률은 50%이다. 이어서 두 명째를 뽑아 연속으로 과반수가 아닐 확률은 50% * 50% = 25% 이다. 이와 같은 계산을 해볼 때, 20명의 난쟁이를 확인하여 과반수가 넘는 모자의 색이 존재함에도 불구하고 그 색이 단 한 번도 뽑히지 않을 확률은 0.000095367% 로 매우 희박하다. 따라서 10000가지 색이 아닌 20명의 난쟁이를 뽑아 검토하는 것으로 문제의 조건을 충분히 해결할 수 있다. 위 알고리즘들을 이용하여 4136ms의 결과로 문제를 통과할 수 있었다.

내 풀이(4):

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

import random
import sys
input = sys.stdin.readline
def cal_cnt(random_color, A, B):
    low = 0
    high = len(record[random_color]) - 1
 
    # Lower_bound
    while low < high:
        m = (low + high) // 2
        if record[random_color][m] < A:
            low = m + 1
        else:
            high = m
    if record[random_color][high] < A:
        return 0
    else:
        start = high
 
    # upper_bound
    low = 0
    high = len(record[random_color])
    while low < high:
        m = (low + high) // 2
        if record[random_color][m] <= B:
            low = m + 1
        else:
            high = m
    high -= 1
    if record[random_color][high] > B:
        return 0
    else:
        end = high
 
    return end - start + 1
 
 
N, C = map(int, input().split())
caps = [0] + list(map(int, input().split()))
record = {}
for idx, color in enumerate(caps):
    if color not in record:
        record[color] = [idx]
    else:
        record[color].append(idx)
 
M = int(input())
visited = {}
for _ in range(M):
    A, B = map(int, input().split())
    check = (B - A + 1) // 2
    check_color = {}
    if A in visited:
        if B in visited[A]:
            print(visited[A][B])
            continue
 
    for _ in range(20):
        random_color = caps[random.randint(A, B)]
        if random_color in check_color:
            continue
        else:
            check_color[random_color] = 1
        cnt = cal_cnt(random_color, A, B)
        if cnt > check:
            print('yes', random_color)
            if A not in visited:
                visited[A] = {}
            visited[A][B] = 'yes ' + str(random_color)
            break
    else:
        print('no')
        if A not in visited:
            visited[A] = {}
        visited[A][B] = 'no'

 

python3, 1068ms

segment tree를 만드는 데 시간이 오래 걸리지 않을까 하는 생각에 특정 구간에서 특정 색에 대한 모자 수를 세는 방법을 upper_bound와 lower_bound를 이용하여 해결하였다. 이를 이용하기 위해 미리 각 모자 색마다 등장하는 index를 저장해주고 난수로 발생시킨 random_color에 대한 리스트에서 A, B 조건에 만족하는 lower_bound와 upper_bound의 index 차이로 이 역시 O(logN)이라는 시간복잡도로 개수를 구할 수 있다. 다만 이 방법은 처음 데이터를 읽어드리는 순간 바로 색깔별 리스트를 만들어줄 수 있기 때문에 사전 준비에 시간을 필요로 하지 않는다.

Python 언어로는 푼 사람도 없고 인터넷으로도 풀이를 찾아볼 수 없어 문제를 푸는 데 여러 알고리즘에 대해 고민하고 공부하여 어렵게 문제를 해결하였다. 효율성에 관한 알고리즘 해결에 힘을 쓰고 있지만 여전히 배워야하고 실수하지 않아야 할 부분이 많은 것 같다.

파이썬으로 풀어보는 백준 1700번: 멀티탭 스케줄링

코딩하는 낙타 — Sat, 16 May 2020 10:03:30 +0900

https://www.acmicpc.net/problem/1700

1700번: 멀티탭 스케줄링

기숙사에서 살고 있는 준규는 한 개의 멀티탭을 이용하고 있다. 준규는 키보드, 헤어드라이기, 핸드폰 충전기, 디지털 카메라 충전기 등 여러 개의 전기용품을 사용하면서 어쩔 수 없이 각종 전

www.acmicpc.net

내 풀이:

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

N, K = map(int,input().split())
sequence = list(map(int,input().split()))
history = [[] for _ in range(101)]
 
for idx, num in enumerate(sequence):
    history[num].append(idx)
 
socket = {}
 
ans = 0
for idx, num in enumerate(sequence):
    if len(socket) < N:
        socket[num] = 1
 
    elif num in socket:
        pass
 
    else:
        del_idx = idx
        del_num = 101
        for check in socket:
            for check_idx in history[check]:
                if check_idx > idx:
                    if del_idx < check_idx:
                        del_idx = check_idx
                        del_num = check
                    break
            else:
                del_num = check
                break
 
        del socket[del_num]
        socket[num] = 1
        ans += 1
 
print(ans)

 

Python3, 64ms

콘센트가 꽂혀있는 전자기기 번호들을 socket이라는 딕셔너리에 저장했다. 이후 해싱 효과를 노리고 history라는 리스트에 각 전자기기별 꽂아야 하는 순서를 저장하였다. 그러나 결과적으로는 history를 따로 만들지 않고 특정 인덱스 이후의 전자기기들을 검토하는 방법이 시간이 더 짧게 나오는 것을 확인할 수 있었다. 이번 문제는 전형적인 그리디 알고리즘 문제라고 할 수 있겠다.

파이썬으로 풀어보는 백준 1967번: 트리의 지름

코딩하는 낙타 — Sat, 2 May 2020 22:57:59 +0900

https://www.acmicpc.net/problem/1967

1967번: 트리의 지름

파일의 첫 번째 줄은 노드의 개수 n(1 ≤ n ≤ 10,000)이다. 둘째 줄부터 n번째 줄까지 각 간선에 대한 정보가 들어온다. 간선에 대한 정보는 세 개의 정수로 이루어져 있다. 첫 번째 정수는 간선이 연결하는 두 노드 중 부모 노드의 번호를 나타내고, 두 번째 정수는 자식 노드를, 세 번째 정수는 간선의 가중치를 나타낸다. 간선에 대한 정보는 부모 노드의 번호가 작은 것이 먼저 입력되고, 부모 노드의 번호가 같으면 자식 노드의 번호가 작은 것이 먼

www.acmicpc.net

내 풀이:

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

from collections import deque
 
class Node:
    def __init__(self, num, val, parent = None):
        self.num = num
        self.val = val
        self.parent = parent
        self.children = []
 
 
class Tree:
    def __init__(self, N):
        self.root = Node(1, 0)
        self.current = None
        self.node_list = [0] * (N+1)
        self.node_list[1] = self.root
 
 
    def append(self, parent, num, val):
        now = self.node_list[parent]
        new = Node(num, val, now)
        now.children.append(new)
        self.node_list[num] = new
 
 
    def BFS(self, node, N):
        q = deque()
        q.append((node, 0))
        visited = [False] * (N+1)
        visited[node.num] = True
        max_length = 0
        ans = 0
        while q:
            data = q.popleft()
            self.current = data[0]
            if data[1] > max_length:
                max_length = data[1]
                ans = data[0]
 
            if self.current.parent and not visited[self.current.parent.num]:
                visited[self.current.parent.num] = True
                q.append((self.current.parent, data[1] + self.current.val))
 
            for child in self.current.children:
                if not visited[child.num]:
                    visited[child.num] = True
                    q.append((child, data[1] + child.val))
 
        self.current = ans
        return max_length
 
 
N = int(input())
tree = Tree(N)
 
for i in range(N-1):
    parent, child, val = map(int,input().split())
    tree.append(parent, child, val)
 
tree.BFS(tree.root, N)
print(tree.BFS(tree.current, N))

 

Python3, 540ms

먼저 클래스를 이용하여 트리를 구현한 경우이다. 문제를 풀기 위한 알고리즘으로는 트리의 Root에서 거리가 가장 먼 노드를 찾아 저장한 후, 저장한 노드를 출발 지점으로 하여 가장 먼 노드까지의 거리를 출력하였다. 이 방법의 단점은 트리를 만들기 위한 행위를 제외하고 트리 전체 탐색만 2번을 해야 한다는 점이다. 이 문제는 최대 만 개의 노드 정보를 받아야 하기 때문에 import sys 후 input = sys.stdin.readline() 처리를 해준다면 120ms 정도의 시간이 걸리는 것을 확인할 수 있다.

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

import sys
from collections import deque
 
N = int(sys.stdin.readline())
Tree = [[0, [], 0] for _ in range(N+1)] # [[parent, child, val], ... , ]
 
for _ in range(N-1):
    parent, child, val = map(int,sys.stdin.readline().split())
    Tree[parent][1].append(child)
    Tree[child][0] = parent
    Tree[child][2] = val
 
q = deque()
q.append((1, 0))
visited = [False] * (N+1)
visited[1] = True
 
distance = 0
furthest = 0
 
while q:
    data = q.popleft()
    cur = data[0]
    res = data[1]
 
    if distance < res:
        distance = res
        furthest = cur
 
    parent = Tree[cur][0]
    children = Tree[cur][1]
    if parent and not visited[parent]:
        visited[parent] = True
        q.append((parent, res + cur[2]))
 
    for child in children:
        if not visited[child]:
            visited[child] = True
            q.append((child, res + Tree[child][2]))
 
distance = 0
q = deque()
q.append((furthest, 0))
visited = [False] * (N+1)
visited[furthest] = True
while q:
    data = q.popleft()
    cur = data[0]
    res = data[1]
 
    if distance < res:
        distance = res
        furthest = cur
 
    parent = Tree[cur][0]
    children = Tree[cur][1]
    if parent and not visited[parent]:
        visited[parent] = True
        q.append((parent, res + Tree[cur][2]))
 
    for child in children:
        if not visited[child]:
            visited[child] = True
            q.append((child, res + Tree[child][2]))
 
print(distance)

 

Python3, 120ms

이 풀이도 알고리즘은 동일하기 때문에 시간은 524ms가 나왔으나 readline()을 이용하여 120ms가 나온 것을 확인할 수 있다. 클래스 대신 리스트를 이용하여 트리를 구현해주기 위해 2차원 리스트를 이용해주었으며 구조는 주석으로 달아놓은 것과 같다. 클래스에 비해 구조를 머릿속으로 그리기 어렵지만 코드 길이 자체는 더 짧기 때문에 트리에 충분히 적응하여 리스트를 이용하는 것이 바람직해 보인다.

파이썬으로 풀어보는 백준 1991번: 트리 순회

코딩하는 낙타 — Mon, 27 Apr 2020 17:07:50 +0900

https://www.acmicpc.net/problem/1991

1991번: 트리 순회

첫째 줄에는 이진 트리의 노드의 개수 N(1≤N≤26)이 주어진다. 둘째 줄부터 N개의 줄에 걸쳐 각 노드와 그의 왼쪽 자식 노드, 오른쪽 자식 노드가 주어진다. 노드의 이름은 A부터 차례대로 영문자 대문자로 매겨지며, 항상 A가 루트 노드가 된다. 자식 노드가 없는 경우에는 .으로 표현된다.

www.acmicpc.net

내 풀이:

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

class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None
 
 
class Tree:
    def __init__(self, root, left, right):
        self.root = Node(root)
        if left != '.':
            self.root.left = Node(left)
        if right != '.':
            self.root.right = Node(right)
        self.current = self.root
 
 
    def append(self, parent, left, right):
        self.current = self.root
        stack = []
        if self.current.right:
            stack.append(self.current.right)
        if self.current.left:
            stack.append(self.current.left)
        while stack:
            self.current = stack.pop()
            if self.current.data == parent:
                if left != '.':
                    self.current.left = Node(left)
                if right != '.':
                    self.current.right = Node(right)
                return
 
            if self.current.right:
                stack.append(self.current.right)
            if self.current.left:
                stack.append(self.current.left)
 
 
    def PreOrder(self, now):
        print(now.data, end='')
        if now.left:
            self.PreOrder(now.left)
        if now.right:
            self.PreOrder(now.right)
 
    def InOrder(self, now):
        if now.left:
            self.InOrder(now.left)
        print(now.data, end='')
        if now.right:
            self.InOrder(now.right)
 
    def PostOrder(self, now):
        if now.left:
            self.PostOrder(now.left)
        if now.right:
            self.PostOrder(now.right)
        print(now.data, end='')
 
 
N = int(input())
root, left, right = input().split()
tree = Tree(root, left, right)
for _ in range(N-1):
    parent, left, right = input().split()
    tree.append(parent, left, right)
 
tree.PreOrder(tree.root)
print()
tree.InOrder(tree.root)
print()
tree.PostOrder(tree.root)
print()

 

Python3, 64ms

클래스를 이용한 트리의 구현.

Code Jam 2020 본선 Round 1B 후기

코딩하는 낙타 — Mon, 20 Apr 2020 10:11:29 +0900

https://codingcompetitions.withgoogle.com/codejam

Code Jam 본선 Round 1의 경우 3번의 시험이 있는데 Round 1A, Round 1B, Round 1C 중 단 한 번이라도 1500등 안에 들면 본선 Round 2에 진출할 수 있다.

Round 1B는 한국시간 기준 2020.04.20 / 01:00 ~ 03:30, 2시간 반동안 진행되었다. Round 1A 때와 똑같이 3문제가 주어졌으며 시험 난이도는 Round 1A보다 어려웠다. 또한 새벽시간대에서 시험을 치러야 했기 때문에 아침 시간대보다는 좀 부담스러웠다.

첫 번째 문제는 간단한 BFS 문제였는데 효율성까지 통과하기 위해서 어느 정도의 가지치기를 위한 구현에 신경써야 했다. 두 번째 문제는 예선에서 나왔던 Interactive 문제가 출제되었는데 이는 푸는 방법 자체를 몰라서 문제 난이도와 상관없이 건들 수 없었다. 다음에 다시 이러한 문제가 출제될 것을 감안하여 따로 공부하는 과정이 필요할 것 같다. 마지막 세 번째 문제는 내 생각에는 브루트포스를 가장한 시뮬레이션? 규칙성을 읽는 문제라고 생각하여 간단하게 코드를 작성하였는데 WA (Wrong Answer)되어 점수를 얻지 못했다. 아직까지도 반례를 전혀 모르겠어서 상당히 답답하다.

이번 시험에서는 내가 할 수 있는 선에서 문제를 꽤 효율적으로 푼 것 같다. 특히 첫 번째 문제의 경우 30분 만에 풀었기 때문에 순조로웠는데 세 번째 문제에서 sample을 좀 더 주었다면 이를 비교해가며 문제를 풀 수 있지 않았을까 하는 아쉬움이 있다.

파이썬으로 풀어보는 백준 1949번: 우수 마을

코딩하는 낙타 — Sun, 12 Apr 2020 22:50:07 +0900

https://www.acmicpc.net/problem/1949

1949번: 우수 마을

N개의 마을로 이루어진 나라가 있다. 편의상 마을에는 1부터 N까지 번호가 붙어 있다고 하자. 이 나라는 트리(Tree) 구조로 이루어져 있다. 즉 마을과 마을 사이를 직접 잇는 N-1개의 길이 있으며, 각 길은 방향성이 없어서 A번 마을에서 B번 마을로 갈 수 있다면 B번 마을에서 A번 마을로 갈 수 있다. 또, 모든 마을은 연결되어 있다. 두 마을 사이에 직접 잇는 길이 있을 때, 두 마을이 인접해 있다고 한다. 이 나라의 주민들에게 성취감을 높여 주

www.acmicpc.net

내 풀이:

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

def DFS(current):
    visited[current] = True
    s = [current]
    DP[current][0] = population[current]
    while s:
        current = s[-1]
        for next in connection[current]:
            if not visited[next]:
                s.append(next)
                visited[next] = True
                DP[next][0] = population[next]
                break
 
        else:
            s.pop()
            if s:
                DP[s[-1]][0] += DP[current][1]
                DP[s[-1]][1] += max(DP[current][0], DP[current][1])
 
 
N = int(input())
population = [0] + list(map(int,input().split()))
connection = [[] for _ in range(N+1)]
for i in range(N-1):
    a, b = map(int,input().split())
    connection[a].append(b)
    connection[b].append(a)
 
DP = [[0, 0] for _ in range(N+1)]
visited = [False] * (N+1)
DFS(1)
print(max(DP[1][0], DP[1][1]))
 

 

Python3, 500ms

문제가 제법 까다로웠다. 트리 형태의 문제지만 그리디 알고리즘을 이용하여 문제를 풀어야 했다. 문제 조건 중 '우수 마을'로 선정되지 못한 마을은 적어도 하나의 '우수 마을'과는 인접해 있어야 한다는 조건이 있는데 '우수 마을'로 선정된 마을 주민 수의 총합을 최대로 해야 한다는 조건을 만족시키기 위해서 자연스럽게 해결되는 부분이기 때문에 세 번째 조건은 무시해줘도 된다. 문제를 풀 때 sys를 import 하는 것은 지양하고 있기 때문에 처음에는 재귀로 구현했다가 파이썬 재귀 제한(1000번)에 걸려 런타임 에러가 났다. 이를 해결하기 위해 어쩔 수 없이 DFS를 스텍 형태로 구현하였는데 for-else문을 이용하는 이와 같은 방식은 stack이 많이 생길수록 시간이 느려지는 현상이 발생한다. 때문에 백준 기준으로 python을 이용해 문제를 푼 사람들 중 속도가 매우 느린 편으로 제출되었지만 모든 사람들이 sys를 이용하여 재귀 제한을 늘려줬기 때문에 스택 형태의 구현도 연습해볼 필요가 있다고 생각한다. 특히 트리에서 부모를 찾기 위한 아이디어로 스택을 pop() 해준 순간 s[-1]이 pop을 해준 현재의 부모가 된다는 점일 이용해준 것이 주요했다.

Code Jam 2020 본선 Round 1A 후기

코딩하는 낙타 — Sat, 11 Apr 2020 23:50:23 +0900

https://codingcompetitions.withgoogle.com/codejam

Code Jam 본선 Round 1의 경우 3번의 시험이 있는데 Round 1A, Round 1B, Round 1C 중 단 한번이라도 1500등 안에 들면 본선 Round 2에 진출할 수 있다.

Round 1A는 한국시간 기준 2020.04.11 / 10:00 ~ 12:30, 2시간 반동안 진행되었다. 3문제가 주어졌으며 대략 3개 정도의 TEST SET이 주어지며 해당 TEST SET 하나를 모두 통과할 경우 각각 해당하는 배점을 얻는다. 대체로 2개의 TEST SET의 경우 알고리즘을 구현하면 시간 초과 걱정 없이 점수를 얻을 수 있으며 마지막 TEST SET의 경우 Input 값이 매우 크기 때문에 효율성을 고려한 코딩을 하지 않으면 절대 통과할 수 없는 형태이다.

문제가 영어로 나오기 때문에 한글로 된 문제를 풀 때 보다는 많이 불편하였다. 특히 나의 경우는 1번 문제를 잘못 읽은 탓에 거의 1시간이라는 시간을 투자하고도 3개 중 하나의 TEST SET 밖에 통과하지 못했다. 이후 남은 1시간 반 중에서 1시간 동안 2번과 3번 문제를 풀었는데 효율성 관련 TEST SET을 통과하기 위한 알고리즘을 거의 손대지 못했다. 남은 30분 동안 1번 문제로 돌아가 문제를 풀려고 노력하였으나 결국 디버깅에 실패했다.

예선 라운드 때는 공책을 준비하여 손 코딩 이후 문제를 풀었는데 이번 라운드에서는 바로 코딩에 들어가면서 실수가 잦았던 것 같다. 조금 더 진지한 자세로 임하여 문제를 풀 수 있도록 해야할 것이다.

파이썬으로 구현해보는 자식수가 정해지지 않은 트리 (폴더 생성과 삭제)

코딩하는 낙타 — Tue, 7 Apr 2020 06:53:50 +0900

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

class Node:
    def __init__(self, data, href):
        self.data = data
        self.href = href
        self.child = []
        self.parent = None
 
 
class Tree:
    def __init__(self):
        self.dummy = Node('dummy', None)
        self.current = self.dummy
        root = Node('/', '/')
        root.parent = self.dummy
        self.dummy.child.append(root)
        self.root = root
 
 
    def mkdir(self, href):
        self.current = self.dummy
        word = ''
        for c in href:
            word += c
            if c == '/':
                for idx in range(len(self.current.child)):
                    if self.current.child[idx].data == word:
                        self.current = self.current.child[idx]
                        word = ''
                        break
                else:
                    new_node = Node(word, href)
                    new_node.parent = self.current
                    self.current.child.append(new_node)
                    self.current = new_node
 
 
    def delete(self, href):
        self.current = self.dummy
        word = ''
        for c in href:
            word += c
            if c == '/':
                for idx in range(len(self.current.child)):
                    if self.current.child[idx].data == word:
                        self.current = self.current.child[idx]
                        word = ''
                        break
        delete_name = self.current.data
        self.current = self.current.parent
        for idx in range(len(self.current.child)):
            if self.current.child[idx].data == delete_name:
                self.current.child.pop(idx)
                break
 
 
    def list(self):
        self.current = self.dummy
        s = [self.current]
        while s:
            self.current = s.pop()
            for child in self.current.child:
                print(child.href)
                s.append(child)
 
 
tree = Tree()
tree.mkdir('/folder1/')
tree.mkdir('/folder2/')
tree.mkdir('/folder3/')
tree.mkdir('/folder2/folder4/')
print('삭제 전')
tree.list()
print('삭제 후')
tree.delete('/folder2/')
tree.list()

 

현재 보완해야할 점은 child를 list에 담아두어 탐색하는 방식인데 delete함수가 작동할 때 삭제하고자 하는 것과 일치하는 폴더를 찾아 index를 읽어 pop을 한다. 이 부분은 child를 linked list로 구현하면 시간 단축에 기여할 수 있을 것이다.

파이썬으로 풀어보는 백준 13460번: 구슬 탈출 2 (삼성 SW 역량 테스트 기출 문제)

코딩하는 낙타 — Sun, 5 Apr 2020 23:28:14 +0900

https://www.acmicpc.net/problem/13460

13460번: 구슬 탈출 2

첫 번째 줄에는 보드의 세로, 가로 크기를 의미하는 두 정수 N, M (3 ≤ N, M ≤ 10)이 주어진다. 다음 N개의 줄에 보드의 모양을 나타내는 길이 M의 문자열이 주어진다. 이 문자열은 '.', '#', 'O', 'R', 'B' 로 이루어져 있다. '.'은 빈 칸을 의미하고, '#'은 공이 이동할 수 없는 장애물 또는 벽을 의미하며, 'O'는 구멍의 위치를 의미한다. 'R'은 빨간 구슬의 위치, 'B'는 파란 구슬의 위치이다. 입력되는 모든 보드

www.acmicpc.net

내 풀이:

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

def move(y, x, dirc):
    ny = y + dy[dirc]
    nx = x + dx[dirc]
    distance = 0
    while arr[ny][nx] == '.':
        distance += 1
        ny += dy[dirc]
        nx += dx[dirc]
    if arr[ny][nx] == 'O':
        return ny, nx, distance
    else:
        return ny - dy[dirc], nx - dx[dirc], distance
 
 
def BFS(Ry, Rx, By, Bx):
    q = [(Ry, Rx, By, Bx)]
    visited[Ry][Rx][By][Bx] = True
    cnt = 1
    while q and cnt <= 10:
        for i in range(len(q)):
            Ry, Rx, By, Bx = q.pop(0)
            for dirc in range(4):
                nRy, nRx, R_move = move(Ry, Rx, dirc)
                nBy, nBx, B_move = move(By, Bx, dirc)
 
                if arr[nBy][nBx] == 'O':
                    continue
                elif arr[nRy][nRx] == 'O':
                    return cnt
                else:
                    if nRy == nBy and nRx == nBx:
                        if R_move > B_move:
                            nRy -= dy[dirc]
                            nRx -= dx[dirc]
                        else:
                            nBy -= dy[dirc]
                            nBx -= dx[dirc]
 
                        if not visited[nRy][nRx][nBy][nBx]:
                            visited[nRy][nRx][nBy][nBx] = True
                            q.append((nRy, nRx, nBy, nBx))
                    else:
                        if not visited[nRy][nRx][nBy][nBx]:
                            visited[nRy][nRx][nBy][nBx] = True
                            q.append((nRy, nRx, nBy, nBx))
        cnt += 1
    return -1
 
 
dy = [-1, 0, 1, 0]
dx = [0, 1, 0, -1]
 
N, M = map(int,input().split())
arr = [list(input()) for _ in range(N)]
visited = [[[[False]*M for _ in range(N)] for _ in range(M)] for _ in range(N)]
for i in range(N):
    for j in range(M):
        if arr[i][j] == 'B':
            By = i
            Bx = j
            arr[i][j] = '.'
        elif arr[i][j] == 'R':
            Ry = i
            Rx = j
            arr[i][j] = '.'
 
print(BFS(Ry, Rx, By, Bx))

 

Python3, 60ms

이 문제의 핵심은 BFS를 구현할 때 visited를 어떻게 처리하느냐에 있다. 나는 어떤 순간의 빨간 공의 좌표와 파란 공의 좌표가 완전히 일치한 적이 있다면 이를 visited를 통해 걸러주었다. 총 4개의 좌표를 읽어 들여야 하기 때문에 4차원 배열을 만들어야 했다. 이후에는 일반적인 BFS 알고리즘을 구현하였다. 다만 주의해야 할 점 2가지 중 첫 번째는 공이 벽에 닿았을 때는 벽에 닿기 전의 좌표를 반환하여야 하고 구멍에 들어갔을 때는 구멍의 좌표를 반환해주어야 한다는 것이다. 두 번째로는 cnt를 하나씩 올릴 때 구멍에 도달한 순간의 cnt값과 cnt를 올려주는 순간을 잘못 배치하면 cnt가 11일 때도 답으로 처리될 수 있다. 만약 답안을 제출하고 69%에서 오답처리를 받았다면 앞서 언급한 실수가 있을 것이다.

파이썬으로 풀어보는 백준 3954번: Brainf**k 인터프리터 (삼성 A형 기출 문제)

코딩하는 낙타 — Fri, 3 Apr 2020 15:36:31 +0900

https://www.acmicpc.net/problem/3954

3954번: Brainf**k 인터프리터

문제 Brainf**k 프로그램이 주어졌을 때, 이 프로그램이 끝나는지, 무한 루프에 빠지는지 알아내는 프로그램을 작성하시오. Brainf**k 인터프리터는 정수를 담는 하나의 배열(unsigned 8-bit 정수)과, 그 배열의 칸 하나를 가리키는 포인터로 이루어져 있다. Brainf**k 프로그램은 다음과 같이 8개의 명령어로 이루어져 있다. - 포인터가 가리키는 수를 1 감소시킨다. (modulo 28) + 포인터가 가리키는 수를 1 증가시킨다. (

www.acmicpc.net

내 풀이:

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

def go(c):
    global pointer, sm, data_idx, si, code_idx, sc, max_code_idx
    if c == '-':
        arr[pointer] -= 1
        if arr[pointer] == -1:
            arr[pointer] = 255
    elif c == '+':
        arr[pointer] += 1
        if arr[pointer] == 256:
            arr[pointer] = 0
    elif c == '<':
        pointer -= 1
        if pointer == -1:
            pointer = sm-1
    elif c == '>':
        pointer += 1
        if pointer == sm:
            pointer = 0
    elif c == '[':
        if arr[pointer] == 0:
            code_idx = teleport[code_idx]
    elif c == ']':
        if arr[pointer] != 0:
            code_idx = teleport[code_idx]
    elif c == '.':
        pass
    elif c == ',':
        if data_idx < si:
            arr[pointer] = ord(data[data_idx])
            data_idx += 1
        else:
            arr[pointer] = 255
    code_idx += 1
    max_code_idx = max(max_code_idx, code_idx)
 
 
def Loops_check():
    global code_idx, sc, max_code_idx
    cnt = 0
    while code_idx <= sc-1:
        cnt += 1
        go(code[code_idx])
        if cnt >= 50000000:
            print("Loops", teleport[max_code_idx], max_code_idx)
            return
    print("Terminates")
    return
 
cnt = 0
for tc in range(1, int(input()) + 1):
    sm, sc, si = map(int,input().split())
    arr = [0] * sm
    pointer = 0
    code = input()
    code_idx = 0
    data = input()
    data_idx = 0
 
    teleport = [0] * sc
    save = [-1] * (sc//2)
 
    cnt = 0
    for idx, c in enumerate(code):
        if c == '[':
            save[cnt] = idx
            cnt += 1
        elif c == ']':
            cnt -= 1
            teleport[save[cnt]] = idx
            teleport[idx] = save[cnt]
            save[cnt] = -1
    max_code_idx = 0
   Loops_check()

 

PyPy3, 4264ms

다른 언어에 비해 파이썬으로 풀기에는 매우 불리한 문제였다. 다른 언어에서의 개념이 없다는 전제하에 문제의 설명이 매우 불친절하기 때문이다. modulo 256 이기 때문에 255에서 256으로 넘어가면 0으로 가야 하고 0에서 -1로 가면 255로 넘어가야 한다. 또한 c언어에서는 int형 배열을 만들고 문자를 넣었을 때 아스키코드로 바꿔주는 과정이 필요 없는 것으로 알고 있다. 이 문제를 풀기 위해서는 문자열을 아스키코드로 바꾸는 ord() 함수가 필수적이다. 알고리즘만을 공부한다면 잊어버렸을 수도 있는 함수이다. 또한 무한 루프가 걸렸을 때 출력해야 할 수의 기준이 순환하고 있는 루프가 아닌 처음으로 무한루프를 돌게 만드는 가장 큰 루프이다. 이 부분 역시 설명이 불충분하여 문제를 풀기 쉽지 않았을 것이라 생각한다. 또한 이 문제는 많은 반복문을 순회해야 하기 때문에 python3로는 불가능하다고 판단된다.