O'bin and the Chocolate Factory

SQLD(SQL 개발자) 7시간 벼락치기 합격 후기

O'bin — Wed, 6 Nov 2024 23:19:56 +0900

시험 정보

SQL 자격증 종류 : SQLP(SQL 전문가), SQLD(SQL 개발자)

SQLD는 SQLP에 비해 난이도 낮음

응시 자격 조건이 없고 비교적 쉬운 난이도로 응시자 많음

상세 설명은 아래 홈페이지 참고

(SQLD 응시자격, 시험 내용, 배점, 합격기준 등)

https://www.dataq.or.kr/www/sub/a_04.do

베이스

벼락치기 전문가

IT 관련 학과 4학년

대학에서 데이터베이스 과목 수강

프로젝트에서 DB 사용 경험 O (MySql, MariaDB)

학습방법

유튜브 강의 → 정리본 2회독 → 중요부분 암기

준비기간 : 7시간

합격점수 : 68점/100점 (60점 이상 합격)

후기

IT 관련 학과 전공자 or DB 기초 개념 O
- 단시간 내 취득 가능
DB 지식 전혀 없는 비전공자
- 하루 2-3시간 한두달 정도 공부하면 합격 가능
- ↑ 실제로 합격한 문과 친구 공부량

백준_python 1753번 최단경로 (그래프, 다익스트라 )

O'bin — Wed, 18 Sep 2024 23:33:17 +0900

<문제 링크>

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

<정답 코드>

sol1 ) 다익스트라 알고리즘으로 최단경로 탐색

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

import sys
import heapq
input = sys.stdin.readline
 
def dijkstra(s, dis):
    dis[s] = 0
    q = []
    heapq.heappush(q, (0, s))
    while q:
        cur_dis, now = heapq.heappop(q)
        if cur_dis > dis[now]:
            continue
        for n, weight in graph[now]:
            cost = cur_dis + weight
            if cost < dis[n]:
                dis[n] = cost
                heapq.heappush(q, (cost, n))
 
V, E = map(int, input().split())
K = int(input())
 
graph = [[] for _ in range(V+1)]
 
for _ in range(E):
    u, v, w = map(int, input().split())
    graph[u].append((v, w))
 
# 최단경로 탐색 전 무한대(inf)로 초기화
dis = [float('inf')] * (V+1)
 
dijkstra(K, dis)
 
for i in dis[1:]:
    if i != float('inf'):
        print(i)
 
    # i가 무한대인 경우 경로 존재 x
    else:
        print('INF')

cs

최단경로 문제의 다양한 상황과 조건에 따라 경로 탐색하는 방법을 더 연습해야겠다

백준_python 1158번 요세푸스 문제 (deque, 수학, 시간복잡도)

O'bin — Sun, 15 Sep 2024 23:52:57 +0900

<문제 링크>

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

<정답 코드>

sol1 ) deque을 이용한 풀이

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

from collections import deque
 
n, k = map(int, input().split())
q1 = deque([i for i in range(1,n+1)])
answer = []
 
for _ in range(n):
    for _ in range(k-1):
        q1.append(q1.popleft())
    answer.append(q1.popleft())
 
print('<',end='')
print(*answer, sep=', ', end='>')

cs

deque를 이용한 직관적 풀이

그러나 시간복잡도가 O(N*k)로, k 크기 증가하면 비효율적

sol2 ) 요세푸스 문제 수학적 풀이

1
2
3
4
5
6
7
8
9
10
11

n, k = map(int, input().split())
people = list(range(1, n + 1))
answer = []
index = 0
 
while people:
    index = (index + k - 1) % len(people)
    answer.append(people.pop(index))
 
print('<', end='')
print(*answer, sep=', ', end='>')

cs

deque이 아니라 리스트 사용

인덱스를 계산해서 배열 값에 직접 접근

시간복잡도 O(N)으로 개선

백준_python 5397번 키로거 (스택, 연결리스트(LinkedList))

O'bin — Sat, 14 Sep 2024 23:12:36 +0900

<문제 링크>

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

<정답 코드>

sol1 ) stack을 이용한 풀이

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

import sys
input = sys.stdin.readline
 
t = int(input())
 
for _ in range(t):
    str1 = []
    str2 = []
    for i in input().rstrip():
        if i == '-':
            if str1:
                str1.pop()
        elif i == '<':
            if str1:
                str2.append(str1.pop())
        elif i == '>':
            if str2:
                str1.append(str2.pop())
        else:
            str1.append(i)
    
    str1.extend(reversed(str2))
    print(''.join(str1))

cs

커서를 기준으로 두 개의 스택(str1, str2) 사용

커서 왼쪽 문자들은 str1에, 커서 오른쪽 문자들은 str2에 역순(스택 특성)으로 저장

최종 결과는 str1과 str2를 조합해 완성

sol 2 ) 연결리스트(linked list)를 이용한 풀이

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
input = sys.stdin.readline
 
class Node:
    def __init__(self, data=None):
        self.data = data
        self.prev = None
        self.next = None
        
class LinkedList:
    def __init__(self):
        self.head = Node()          # 더미 헤드 노드
        self.cursor = self.head     # 커서는 헤드에 저장
 
    def insert(self, data):
        new_node = Node(data)
        new_node.prev = self.cursor
        new_node.next = self.cursor.next
 
        if self.cursor.next:
            self.cursor.next.prev = new_node
        
        self.cursor.next = new_node
        self.cursor = new_node
    
    def delete(self):
        if self.cursor is not self.head:    # 헤드에서는 삭제 불가
            self.cursor.prev.next = self.cursor.next
            if self.cursor.next:
                self.cursor.next.prev = self.cursor.prev
            self.cursor = self.cursor.prev  # 삭제 후 커서 왼쪽으로 이동
    
    def move_left(self):
        if self.cursor is not self.head:
            self.cursor = self.cursor.prev
 
    def move_right(self):
        if self.cursor.next:
            self.cursor = self.cursor.next
 
    def get_result(self):
        result = []
        current = self.head.next
 
        while current:
            result.append(current.data)
            current = current.next
 
        return ''.join(result)
 
def main():        
    t = int(input())
    for _ in range(t):
        linked_list = LinkedList()
        
        for c in input().rstrip():
            if c == '-':
                linked_list.delete()
            elif c == '<':
                linked_list.move_left()
            elif c == '>':
                linked_list.move_right()
            else:
                linked_list.insert(c)
        
        print(linked_list.get_result())
 
if __name__ == '__main__':
    main()
Colored by Color Scripter

cs

이중 연결 리스트 사용해 커서 위치 기준으로 노드 삽입 또는 삭제

커서 이동은 연결리스트의 prev와 next 포인터로 처리

< stack과 linked list 비교 >

stack	linked list
구현 단순 시간복잡도 O(1)로 빠름 적은 메모리 사용 커서 이동 많을 경우 두 스택 사이 이동 자주 발생해 비효율적 메모리 부족 발생 가능	커서 이동 시 O(1)로 빠름 동적 메모리 관리 특정 위치 연속 삽입/삭제 작업 효율 좋음 구현 복잡 스택에 비해 포인터 저장 위한 추가 메모리 사용 필요 cache hit rate 낮음

백준_python 13549번 숨바꼭질 (메모리 초과, BFS, 최단거리)

O'bin — Mon, 9 Sep 2024 13:16:57 +0900

<문제 링크>

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

<정답 코드>

sol1 ) 나의 오답 - 메모리 초과

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

from collections import deque
n, k = map(int, input().split())
graph = deque([(n, 0)])
 
while True:
    now, time = graph.popleft()
    
    if now == k:
        print(time)
        break
 
    graph.append((now * 2, time))
    graph.append((now + 1, time + 1))
    graph.append((now - 1, time + 1))

cs

예제는 맞췄지만, 채점 시 메모리 초과 발생

틀린 이유

1. 중복 방문 체크 없음 : 동일 위치 여러번 방문, 큐에 추가

2. 무한 이동 : 이동 후 위치가 목표값인 k를 넘는 경우에도 체크하지 않고 무한 추가

3. 무한 루프 가능성 : 이동 후 위치가 음수인 경우도 체크하지 않고 큐에 추가

4. 비효율적인 큐 처리 : 순간이동의 경우 시간 증가하지 않음에도 큐 맨뒤에 추가

sol2 ) BFS로 탐색 - 정답

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

import sys
from collections import deque
input = sys.stdin.readline
 
def bfs(now, target):
    q = deque([now])
    time[now] = 0   # 방문 처리
 
    while q:
        x = q.popleft()
        # 현재 위치가 target(동생 위치)와 일치하면 시간 리턴
        if x == target:
            return time[x]
        
        for nx in (x-1,x+1,x*2):
            if 0<= nx < limit and time[nx] == -1:
                if nx == 2*x:
                    time[nx] = time[x]
                    # 시간 증가하지 않았으므로 q 맨 앞 추가
                    q.appendleft(nx)    
                else:
                    # 시간 1 증가, q 맨 뒤에 추가
                    time[nx] = time[x] +1
                    q.append(nx)
 
 
# 현재 위치 p, 목표 위치 t 입력 받기
p, t = map(int, input().split())
limit = 100001
time = [-1] * limit     # 방문 체크 및 시간 저장
 
print(bfs(p, t))
Colored by Color Scripter

cs

 

1번 오답 코드의 문제점들을 개선해

- visited 배열로 방문 체크

- 이동 후 위치 범위 체크

- 시간 증가하지 않는 순간이동은 큐 맨 앞, 나머지 시간 증가하는 이동은 큐 맨 뒤에 추가

하여 효율적 메모리 사용 가능하도록 개선

문제에서 주어진 범위 조건들이 메모리 초과, 시간 초과 문제를 해결하기 위한 단서

방문 여부 확인 중요

백준_python 3273번 두 수의 합 (정렬, 투 포인터)

O'bin — Mon, 2 Sep 2024 23:09:24 +0900

<문제 링크>

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

<정답 코드>

sol 1 ) 배열에 인덱스 저장하고 값 비교해 계산

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

n = int(input())
arr = list(map(int, input().split()))
x = int(input())
 
arr2 = [0] * 2000000
for i in range(n):
    arr2[arr[i]] = i
 
cnt = 0
for i in range(n):
    if arr2[x - arr[i]] > i:
        cnt += 1
 
print(cnt)

cs

입력을 arr에 받고, 각 원소를 인덱스로 하는 arr2 배열에 인덱스를 저장했다.

정답이었지만, 문제를 잘못 이해한 풀이고,

메모리 사용(불필요하게 큰 arr2 배열) 측면에서 비효율적인 코드

시간복잡도 : O(n)

sol 2 ) 정렬과 투 포인터를 이용한 풀이

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

n = int(input())
arr = list(map(int, input().split()))
x = int(input())
 
# 배열 정렬 후 포인터 양쪽 끝에 두 개 설정
arr.sort()
left, right = 0, n - 1
cnt = 0
 
while left < right:
    current_sum = arr[left] + arr[right]
    if current_sum == x:
        cnt += 1
        left += 1
        right -= 1
    elif current_sum < x:
        left += 1
    else:
        right -= 1
 
print(cnt)

cs

두 개의 포인터(left, right)를 정렬한 배열 양 쪽 끝에 두고

합이 x와 일치할때까지 이동하며 해당하는 값을 찾는 코드

시간복잡도가 O(n log n)으로 1번 코드보다 약간 느리지만 훨씬 적은 메모리 공간 사용

1번 코드보다 깔끔한 풀이

백준_python 1068번 트리 (DFS)

O'bin — Fri, 23 Aug 2024 10:55:52 +0900

<문제 링크>

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

<정답 코드>

sol ) dfs를 이용한 리프 노드 탐색

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

import sys
input = sys.stdin.readline
 
def dfs(node, tree, visited):
    visited[node] = True
    for i in range(len(tree)):
        if tree[i] == node and not visited[i]:
            dfs(i, tree, visited)
 
n = int(input())
tree = list(map(int, input().split()))
del_node = int(input())
 
visited = [False] * n
 
# 삭제할 노드와 그 자손들 방문 처리
dfs(del_node, tree, visited)
 
# 리프 노드 계산
leaf_cnt = 0
for i in range(n):
    if not visited[i]:
        # 현재 노드가 리프 노드라고 일단 가정
        is_leaf = True
        for j in range(n):
            # 노드 j의 부모 노드가 i이고 삭제되지 않은 경우(not visited[j])
            if tree[j] == i and not visited[j]:
                # i는 리프노드가 아님
                is_leaf = False
                break
        if is_leaf:
                leaf_cnt += 1
 
print(leaf_cnt)
Colored by Color Scripter

cs

DFS로 삭제 대상 노드의 자식 노드들을 모두 방문하고

방문하지 않은 노드 대상으로 리프 노드 여부를 검사해 그 수를 센다.

DFS가 그래프 전체 뿐만 아니라 부분에 대한 탐색을 할 때도 사용할 수 있다는 아이디어를 떠올리지 못했다.

백준_python 1991번 트리 순회 (Node class, 트리, 재귀)

O'bin — Mon, 19 Aug 2024 17:18:22 +0900

<문제 링크>

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

<정답 코드>

sol ) 재귀를 이용한 트리 탐색

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

import sys
input = sys.stdin.readline
 
class Node:
    def __init__(self, item, left, right):
        self.item = item
        self.left = left
        self.right = right
 
def pre_order(node):
    result.append(node.item)
    if node.left != '.':
        pre_order(tree[node.left])
    if node.right != '.':
        pre_order(tree[node.right])
 
def in_order(node):
    if node.left != '.':
        in_order(tree[node.left])
    result.append(node.item)
    if node.right != '.':
        in_order(tree[node.right])
 
def post_order(node):
    if node.left != '.':
        post_order(tree[node.left])
    if node.right != '.':
        post_order(tree[node.right])
    result.append(node.item)
 
# 입력 처리
n = int(input().strip())
tree = {}
for _ in range(n):
    i, l, r = input().strip().split()
    tree[i] = Node(i, l, r)
 
# 전위 순회
result = []
pre_order(tree['A'])
print(''.join(result))
 
# 중위 순회
result = []
in_order(tree['A'])
print(''.join(result))
 
# 후위 순회
result = []
post_order(tree['A'])
print(''.join(result))

cs

line 4~8) 노드 클래스를 선언해 노드에 쉽게 접근할 수 있음

line 10~29) 재귀를 이용해 순회 구현하면 간단함

트리, 재귀 문제 더 풀어보면서 구현 연습을 해야겠다.

백준_python 9372번 상근이의 여행 (그래프, 트리)

O'bin — Thu, 8 Aug 2024 10:43:22 +0900

<문제 링크>

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

<정답 코드>

sol ) DFS로 국가(노드) 탐색하여 비행 횟수 구하기

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

import sys
input = sys.stdin.readline
 
def dfs(node, cnt):
    visited[node] = True
    for n in tree[node]:
        if not visited[n]:
            cnt = dfs(n, cnt+1)
    return cnt
 
t = int(input())
 
for _ in range(t):
    n, m = map(int, input().split())
    tree = [[] for _ in range(n+1)]
    visited = [False] * (n+1)
 
    for _ in range(m):
        u, v = map(int, input().split())
        tree[u].append(v)
        tree[v].append(u)
 
    visited[1] = True
 
    print(dfs(1,0))

cs

DFS로 풀 수 있는 쉬운 문제였다.

그래프(트리) 배열로 구현

백준_python 1967번 트리의 지름 (트리, DFS)

O'bin — Tue, 6 Aug 2024 11:06:58 +0900

<문제 링크>

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

<정답 코드>

sol ) DFS를 이용한 최대 경로 길이 탐색

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

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**5)
 
def dfs(node):
    global max_dia, tree, visited
    # 현재 노드에서 자식 노드로 가는 경로 중 가장 긴 경로 두개 저장
    long_one, long_two = 0, 0
    # 인접 노드 탐색
    for cn, cw in tree[node]:
        if not visited[cn]:
            visited[cn] = True
            path_len = dfs(cn) + cw
            
            if path_len > long_one:
                long_one, long_two = path_len, long_one
            elif path_len > long_two:
                long_two = path_len
    
    max_dia = max(max_dia, long_one + long_two)
    return long_one
 
def main():
    global tree, visited, max_dia
    # 입력
    n = int(input())
    tree = [[] for _ in range(n+1)]
 
    # tree[노드번호] = (부모or자식노드번호, 가중치)
    for _ in range(n-1):
        p, c, w = map(int, input().split())
        tree[p].append((c, w))
        tree[c].append((p, w))
 
    visited = [False] * (n+1)
    max_dia = 0
 
    # 루트 노드에서 탐색 시작
    visited[1] = True
    dfs(1)
 
    print(max_dia)
 
if __name__ == '__main__':
    main()
Colored by Color Scripter

cs