이것저것 코딩하는 블로그

[Algorithm] 프로그래머스 주식 가격

Mon, 24 Apr 2023 22:05:08 +0900

문제 링크: https://school.programmers.co.kr/learn/courses/30/lessons/42584

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

주식 가격의 배열을 stock이라고 할 때, stock[i] 이후로 stock[i]보다 작은 수가 있으면 그 전까지의 length를 기록하면 된다. i번째에서 1초간 유지한 것도 감소하지 않았다고 간주하므로 i번째 배열에 1씩 더하고 시작한다.

def solution(prices):
    n = len(prices)
    answer = [0] * n 
    
    for i in range(n):
        for j in range(i+1, n):
            answer[i] += 1
            if prices[i] > prices[j]:
                break
        
    return answer

[Algorithm] 프로그래머스 전화번호 목록

Mon, 24 Apr 2023 22:01:21 +0900

문제 링크: https://school.programmers.co.kr/learn/courses/30/lessons/42577

프로그래머스

programmers.co.kr

짧은 순서대로 탐색하는 것이 유리하다. 짧은 것이 다른 것의 접두사가 될 확률이 높기 때문이다.

> 이렇게 생각했었는데 문자열대로 정렬하면 [12, 9, 123]일 때 [12, 123, 9]로 정렬된다. 자릿수별 아스키 코드로 정렬하기 때문이다. 이러면 i와 i+1만 비교하면 된다. 같은 숫자로 시작하는 것들끼리 몰리기 때문이다.

따라서 문자열 기준으로 정렬한 후, i번째 수가 i+1번째 수의 접두사인지 확인한다. 단 한 개의 번호만 주어진 경우 무조건 자기 자신의 접두사이므로 예외로 처리한다.

def solution(phone_book):
    phone_book = sorted(phone_book)
    answer = True
    if len(phone_book) == 1:
        return True
    else:
        for i in range(len(phone_book)-1):
            if phone_book[i] == phone_book[i+1][:len(phone_book[i])]:
                return False
    return answer

[Algorithm] 프로그래머스 가장 큰 수

Fri, 14 Apr 2023 23:16:10 +0900

링크: https://school.programmers.co.kr/learn/courses/30/lessons/42746

프로그래머스

programmers.co.kr

처음 생각한 풀이:

32 3222 34 3444 라는 예제를 보고, 맨 뒤만 반복하여 4자리로 정렬 기준 수를 만들어준 뒤 (3222 3222 3444 3444) 이 숫자로 정렬하고, 만약 정렬 기준 수가 같을 때는 원래 수가 더 짧은 기준 정렬 수를 a, 긴 기준 정렬 수를 b라고 했을 때 a[0] > a[-1]이면 a를 앞에 두고, 아니면 b를 앞에 두었다. 이럴 경우 위와 같은 예제를 해결할 수 있고, 뒷부분이 반복되는 경우를 잡을 수 있다고 생각했다.

틀린 이유:

12 1213이라는 반례가 있었다. 3번째 자리까지 같고 4번째 자리에 더 큰 수가 오는 경우를 생각하지 못했다.

풀이:

수를 세 번 반복한 뒤 비교해야 했다. 처음 생각한 풀이에서 맨 앞과 맨 뒤만 비교한 데서 오류가 있었다. a[0]과 a[-1]을 비교한 후에 a[-1]과 a[-2]도 비교해야 하는 것이 틀린 이유였는데, 이것은 결국 문자를 반복하는 것과 같은 효과를 낸다. 따라서 수를 문자열로 바꿔 세 번 반복하고 각 자릿수를 비교하면 된다.

풀이 코드:

numbers = list(map(int, sys.stdin.readline().split()))
tps = []
res = ''

for num in numbers:
    num_str = str(num)
    tps.append((num_str, num_str*3))

tps = sorted(tps, key=lambda x:x[1], reverse=True)
for tp in tps:
    res += str(int(tp[0]))

[Algorithm] Kruskal Algorithm (크루스칼 알고리즘)

Wed, 13 Oct 2021 09:22:36 +0900

1. Minimum Spanning Tree (MST)

MST란, 트리가 주어져 있을 때 모든 노드들이 연결되어 있으면서 가중치의 합이 최소인 spanning tree (tree의 일부분, 부분집합 개념으로 생각하면 된다) 이다. 단, 이는 cycle을 포함해서는 안된다. Spanning tree의 정의 자체가 cycle을 포함하지 않는 것이기 때문이다.

이를 찾아주는 알고리즘이 크루스칼 알고리즘이다.

2. 크루스칼 알고리즘

이는 union-find를 이용하여 MST를 찾아준다. union-find에 대한 글은 다음 링크를 참고하자.

https://codinglilly.tistory.com/32

[Algorithm] Union-Find

1. Union-Find란? 여러 개의 원소가 있고, 여러 개의 집합이 있다고 가정하자. 특정 원소가 어느 집합에 속해있는지 확인하고, 특정 집합을 합쳐야 할때 해당 알고리즘을 사용한다. 집합에 속하는 것

codinglilly.tistory.com

처음에는 가중치의 값이 가장 작은 간선(edge)을 선택한다. 이후 가중치의 값이 작은 순서대로 선택하되, 선택할 때마다 union 연산을 수행한다. 단, union 이전에 find 연산을 수행하여 cycle이 있는지 확인한다.

만약 cycle이 발생하게 된다면, 두 노드는 같은 조상을 갖고 있을 것이다. 따라서 조상이 같을 경우에는 연산을 수행하지 않고 넘어간다. 이 과정을 통해 가중치가 작은 간선들을 선택하게 되면, MST를 만들 수 있다.

2. 구현

n = int(input())
graph = []
edges = []

for i in range(n):
    graph.append(input().split())
for i in range(n):
    for j in range(n):
        graph[i][j] = int(graph[i][j])
        if(graph[i][j] != 0):
            edges.append([i, j, graph[i][j]])

mst = []
uf = [-1 for _ in range(n)]
def find(uf, x):
    if uf[x] == -1:
        return x
    tmp = find(uf, uf[x])
    uf[x] = tmp
    return uf[x]

def union(uf, x, y):
    X, Y = find(uf, x), find(uf, y)
    uf[X] = Y
    return uf

edges.sort(key=lambda x:x[2])
res = 0
max_cost = 0

for edge in edges:
    start, end, cost = edge[0], edge[1], edge[2]
    if find(uf, start) != find(uf, end):
        uf = union(uf, start, end)
        mst.append((start, end))
        res += cost

print(mst, res)

[Algorithm] Union-Find

Wed, 13 Oct 2021 01:12:15 +0900

1. Union-Find란?

여러 개의 원소가 있고, 여러 개의 집합이 있다고 가정하자. 특정 원소가 어느 집합에 속해있는지 확인하고, 특정 집합을 합쳐야 할때 해당 알고리즘을 사용한다. 집합에 속하는 것을 한 원소를 대표로 하여 자식 노드로 이어줌으로써 집합을 구현한다.

1) Union

두 집합을 합치는 연산이다. 두 집합에 속하는 자식 노드들을 모두 찾은 후, 한 집합의 부모 노드를 다른 집합의 자식 노드로 하면 모든 원소가 하나의 부모 노드로 이어지게 된다. 코드로 표현하자면, 부분집합 x의 조상(루트)을 부모로 하고 y를 그 밑에 붙인다고 생각하면, uf(find[x]) = uf(find[y]) 가 된다.

2) Find

집합에 속한 원소를 찾는 연산이다. 부모 노드에 대해 연결된 자식 노드를 찾고, 그 자식 노드의 자식 노드를 더 이상 없을 때까지 계속 찾는 과정으로 이루어진다.

그림으로 보면 다음과 같다. 7개의 노드가 있다고 가정하자.

초기 상태

uf 배열은 자신의 부모 노드를 원소로 가지는 배열이다. 처음에는 부모, 자식 관계가 없으니 -1로 초기화한다.

(0, 2), (4, 5) 두 개의 부분집합이 생겼다고 가정하자. 그 때 배열의 변화는 다음과 같다.

첫 번째 부분집합 생성

누가 부모가 될지는 본인 마음이다. 어차피 소속 여부를 따지는 것이기 때문에 순서는 상관 없다.

그렇게 되면 2는 0의 부모, 5는 4의 부모가 된다. 이 때 find(0) 연산을 수행하면 2를 반호나할 것이고, find(5) 연산을 수행하면 4를 반환할 것이다. 이로써 각각이 같은 집합에 있다는 걸 알 수 있다.

이제 두 집합을 합쳐보자. 위에서 말한 것과 같이, 하나의 부모 노드를 다른 자식 노드의 자식 노드로 만든다.

여기서는 2를 조상으로 하고 나머지를 모두 자식으로 만들겠다.

union 연산 이후

2의 자식인 0을 5의 부모로 만들면 집합이 합쳐진 효과가 일어난다.

그러나 위와 같이 구현하면, 집합이 하나밖에 없을 경우 부모 노드에 대해 자식 노드가 일렬로 이어져 있으므로 순회하는데 O(n)의 시간이 소요된다. 이를 해결하기 위해 find를 호출할 때 조상을 찾아내면, 현재 값의 부모 값을 조상으로 바꾸는 것이다. 다시 말해서, 줄줄이 연결되어있던 자식 노드들이 여러 개의 선을 이용해 하나로 이어지는 것이다.

위의 예제를 그대로 차용하자면, find(4)를 호출하면 5을 찾고, 재귀적인 구조이므로 find(5)가 호출되어 0을 반환한다. 다시 find(0)이 호출되어 2를 반환하고, 2는 조상이 없으므로 find 연산을 종료한다.

이 연산 과정에서 2를 제외한 모두는 2가 조상임을 알게 된다. 따라서 재귀적인 연산이 반환하는 최종 값, 즉 조상을 부모 값으로 한다. 그림으로 나타내면 다음과 같다.

코드로 표현하자면, uf[x] = find(x)였던 기존의 재귀적 구조가 uf[x] = find(uf[x])로 바뀌게 되어 자신의 조상을 계속 바꿀 수 있는 구조가 된다.

2. 구현

uf = [-1 for _ in range(n)]
def find(uf, x):
    if uf[x] == -1:
        return x
    tmp = find(uf, uf[x])
    uf[x] = tmp
    return uf[x]

def union(uf, x, y):
    X, Y = find(uf, x), find(uf, y)
    uf[X] = Y
    return uf

[Algorithm] Floyd-Warshall Algorithm (플로이드-워셜 알고리즘)

Wed, 13 Oct 2021 01:00:24 +0900

1. 플로이드-워셜 알고리즘이란?

다익스트라 알고리즘은 특정 시작점이 있을 때만 사용할 수 있다. 따라서 모든 지점의 거리를 구하는 데는 번거로울 수 있다(모든 점들에 대해 다익스트라 알고리즘을 수행해야 한다). 이 때 사용하는 것이 플로이드-워셜 알고리즘이다.

기본 아이디어는 다익스트라와 유사하다. 단, 이를 모든 노드가 시작점일 때를 고려하여 수행할 뿐이다. A에서 B로 가는 경로보다 A에서 X를 거쳐 B로 가는 경로가 짧다면 최단 경로를 갱신하는 방식이다. 그러나 애초에 모든 점을 방문해야 하므로 다익스트라 알고리즘에 비해 느리다. 따라서 지점의 갯수가 적다면 다익스트라를 여러 번 돌리는 게 나을 수 있다. 코드를 보며 알아보자.

2. 구현

n = int(input())
graph = []
dist = [[0 for _ in range(n)] for _ in range(n)]

for i in range(n):
    graph.append(input().split())
for i in range(n):
    for j in range(n):
        graph[i][j] = int(graph[i][j])
        if graph[i][j] != 0:
            dist[i][j] = graph[i][j]
        elif i == j:
            dist[i][j] = 0
        else:
            dist[i][j] = float('inf')

for k in range(n):
    for i in range(n):
        for j in range(n):
            if dist[i][j] > dist[i][k] + dist[k][j]:
                dist[i][j] = dist[i][k] + dist[k][j]


for i in range(n):
    print(dist[i])

여기서 중요한 것은 k를 포문의 가장 바깥에 두는 것이다. dist[i][j]는 연결될 수 있는 모든 k에 대해서 최적을 구한 뒤 갱신되어야 한다. 그러나 이것이 가장 안으로 들어온다면 처음 k번만 고려된다. 만약 그래프가 한 번 갱신된 이후라면, k가 가장 안쪽에 있을 때는 갱신된 값에 대한 최적의 값을 쓸 수 없다.

[Algorithm] Dijkstra Algorithm (다익스트라 알고리즘)

Wed, 13 Oct 2021 00:51:02 +0900

1. 다익스트라 알고리즘

다익스트라 알고리즘은 가중치가 있는 그래프에서, 특정 시작점에서 다른 모든 정점으로 가는 최단거리를 각각 구해주는 알고리즘이다.

이는 특정 지점까지의 거리 = A까지 가는 거리 + A에서 특정 지점까지 소요되는 거리 라는 아이디어를 기반으로 한다.

과정을 살펴보면 다음과 같다.

1) 거리 배열을 최댓값으로 초기화하고, 출발지의 값만 0으로 설정한다.

2) 현재 방문하지 않은 정점 중 가장 거리 값이 작은 지점을 선택한다.

3) 해당 지점과 인접한 지점들의 거리를 갱신한다.

4) 모든 지점이 선택될 때 까지, 2와 3을 반복한다.

다음 그래프를 통해 살펴보자. 자세한 설명은 다음 링크를 참고하면 된다. 많은 도움을 받았다.

https://www.codetree.ai/missions/6/concepts/37/problems/ga-dijkstra/introduction

코드트리

국가대표가 만든 코딩 공부의 가이드북 코딩 왕초보부터 꿈의 직장 코테 합격까지, 국가대표가 엄선한 커리큘럼으로 준비해보세요.

www.codetree.ai

인접한 지점들과의 거리를 갱신한다는 점에서 큐를 사용하여 구현할 수 있다. 인접한 지점들을 모두 방문하고, 방문된 지점들에 대해 거리를 갱신해야 하기 때문이다. 이진 트리에서 생각해보면, 인접한 지점들을 모두 방문한다는 것은 자식 노드를 모두 방문한다고 생각할 수 있다. 또한 방문한 노드들에 대해 다시 그 노드들의 거리를 갱신하는 것은 이진 트리에서 모든 자식들을 방문한 이후 자식 노드에 대해 다시 탐방을 수행하는 과정이다. 따라서 큐를 사용한다. 모든 노드들을 큐에 넣어놓은 뒤, 시작점, 즉 첫 번째 노드부터 pop하며 순회하면서 최단 거리를 구하면 마지막엔 모든 노드들에 대한 최단 거리를 구할 수 있다.

2. 구현

from collections import deque

n = int(input())
graph = []

for i in range(n):
    graph.append(input().split())
for i in range(n):
    for j in range(n):
        graph[i][j] = int(graph[i][j])

dist = [float("inf") for _ in range(n)]
dist[0] = 0

q = deque()

for i in range(n):
    q.appendleft(i)

while len(q) > 0:
    present, mindist = 0, float("inf")
    for item in q:
        if dist[item] < mindist:
            present = item
            mindist = dist[item]
    print(present)
    q.remove(present)

    for i in range(n):
        if graph[present][i] != 0:
            tmp = dist[present] + graph[present][i]
            if tmp < dist[i]:
                dist[i] = tmp
    print(dist)

[Algorithm] BFS (Breadth First Search)

Wed, 13 Oct 2021 00:37:10 +0900

1. BFS란?

BFS는 너비 우선 탐색으로, 그래프를 층별로 탐색하는 것이다.

자세히 얘기하자면, 한 노드를 방문했을 때 그 노드의 모든 자식 노드를 방문해야 다음 노드로 갈 수 있다.

이 과정을 루트 노드부터 시작해서 모든 리프 노드를 방문할 때까지 반복한다.

DFS와 달리 모든 리프 노드를 방문했다면 탐색이 끝난 것이므로 (맨 아래층에 있으므로) 종료한다.

예제를 통해 살펴보자. 다음과 같은 그래프를 너비 우선 탐색으로 탐색하고자 한다.

먼저 루트 노드인 9를 방문한다. 이후 9의 자식 노드인 8과 6을 방문한다. 자식 노드를 방문했으면, 자식 노드 중 가장 왼쪽으로 이동해 그 노드의 자식들을 모두 방문한다. 여기서는 5와 2가 된다. 이후 오른쪽 노드로 이동해 자식을 방문한다. 여기서는 1이 된다. 따라서 이동 순서는 9 > 8 > 6 > 5 > 2 > 1이 된다.

구현에는 큐를 쓴다. 큐는 먼저 들어온 원소가 먼저 나가는 구조이므로, 모든 자식 노드를 방문한 이후 그 자식들의 부모가 되는 노드를 방문하기 적합하다. 위의 그래프로 예를 들자면, 먼저 9가 큐에 들어가고, 9을 빼면서 9의 자식인 8과 6이 들어간다. 이 때 큐는 [8, 6]이 된다. 이 때 큐를 이용하면 방문해야 하는 9의 왼쪽 자식 노드, 즉 8을 바로 뺄 수 있다.

2. 구현

이진 트리에서의 BFS 코드이다.

from collections import deque

q = deque()
graph = list(map(int, input().split()))
n = len(graph)
visited = [-1 for _ in range(n)]
res = []
q.appendleft(0)

while len(res) != len(graph):
    present = q.popleft()
    print(present)
    if visited[present] == -1:
        visited[present] = 0
        q.appendleft(present)
        res.append(graph[present])

    left = 2 * present + 1
    right = 2 * present + 2

    if left < n:
        q.append(left)
    if right < n:
        q.append(right)

print(res)

결과에 반영되는 연산은 모두 present에서 해야 한다. 현재 노드에서만 결과 삽입 연산을 해야 중복을 방지할 수 있기 때문이다.

queue는 방문할 순서를 담은 자료구조라는 것을 기억하자.

[Algorithm] DFS (Depth First Search)

Tue, 12 Oct 2021 23:56:06 +0900

1. DFS란?

깊이 우선 탐색(DFS)는 의미 그대로 깊이를 우선으로 하여 탐색하는 것이다. 자세히 얘기하자면, 루트 노드에서 시작해서 자식 노드로 이동한다 (보통 왼쪽 노드로 이동한다). 이동한 자식 노드에서 다시 자식 노드로 이동한다. 이 과정을 자식 노드가 없을 때까지 (리프 노드에 갈 때까지) 반복한다. 리프 노드에 도달하면, 리프 노드의 부모 노드로 가서 다시 오른쪽 자식을 방문한다. 오른쪽 자식에서 위에서 했던 과정을 반복한다. 이 재귀적인 방문을 탐방이라고 하겠다. 이렇게 모든 노드를 방문할 때까지 탐방을 완료하면 search가 끝난다.

그래프를 예를 들어보자.

예제 그래프

위와 같은 그래프가 있다고 할때, 깊이 우선 탐색으로 탐색해보자. 루트에서 왼쪽으로 계속 이동하며 리프 노드가 나올 때까지 가므로 처음엔 9 > 8 > 5 순으로 이동할 것이다. 리프 노드에 도달했으므로 부모 노드로 돌아가서 오른쪽 자식을 다시 탐방한다(부모 노드로 돌아가는 것은 순서에 넣지 않는다). 따라서 9 > 8 > 5 > 2 로 이동할 것이다. 마찬가지로 리프 노드이므로 부모 노드로 돌아가고, 모든 자식을 방문했으므로 다시 위로 올라간다. 이후 6 > 1 순으로 탐방한다. 따라서 최종 순서는 9 > 8 > 5 > 2 > 6 > 1이 될 것이다.

구현에는 스택을 쓴다. 리프 노드에서 부모 노드로 돌아갈 때를 생각해보자. 위의 예제에서, 9 > 8 > 5로 이동했으므로, 8로 방문해야 한다. 따라서 방문했다는 의미로 5를 빼고 나면, 그 직전에 들어간 노드인 8을 빼서 8의 자식을 다시 방문해야 한다. 이러한 연유로 스택을 사용하여 구현한다.

2. 구현

이진 트리에서의 DFS 코드이다. 이진 트리를 배열로 나타내는 방법은 다음 링크를 참고하자.

https://codinglilly.tistory.com/16

[Algorithm] Heap Sort (힙 정렬)

0. Heap Sort란? 자료구조인 heap을 이용한 정렬이다. 먼저 heap이 무엇인지 살펴보자. 1) Heap heap은 max-heap, min-heap 두 개로 나눌 수 있다. max-heap을 이해하면 min-heap을 이해하기 쉬우니 max-heap을 살..

codinglilly.tistory.com

n = int(input())
graph = list(map(int, input().split()))
stack = [0]
visited = [-1 for _ in range(n)]
res = []

while len(res) != len(graph):
    print(stack, res)
    present = stack.pop()
    left = 2 * present + 1
    right = 2 * present + 2

    if visited[present] == -1:
        res.append(graph[present])
        stack.append(present)
        visited[present] += 1

    if left < n or right < n:
        if visited[left] == -1 and left < n:
            stack.append(left)
        elif visited[right] == -1 and right < n:
            stack.append(right)
print(res)

left를 먼저 검사하는 특성을 위해 elif 문을 넣어주었다. 방문한 적이 없는 노드가 present가 되면 res, visited를 갱신한다.

이후 왼쪽, 오른쪽 자식을 검사하여 방문한 적이 없으면 다음 차례에서 방문하기 위해 stack에 append한다.

[Algorithm] 회의실 배정 (Meeting room)

Tue, 12 Oct 2021 16:24:06 +0900

0. 문제

link: https://www.codetree.ai/missions/6/concepts/35/problems/scheduling-meeting-room/introduction

코드트리

국가대표가 만든 코딩 공부의 가이드북 코딩 왕초보부터 꿈의 직장 코테 합격까지, 국가대표가 엄선한 커리큘럼으로 준비해보세요.

www.codetree.ai

하나의 회의실이 있고, n개의 회의 요청이 들어왔다. 각 회의의 시작 시간과 끝 시간이 주어져 있으며, 한 회의가 시작되면 도중에 그만둘 수 없고, 한 회의가 끝나는 직후에 동시에 다른 회의가 시작될 수 있다. 적절하게 회의 요청을 수락하여 최대로 많은 회의가 진행되도록 만들어보자.

이 문제는 회의 끝 시간을 기준으로 정렬하여 가장 빨리 끝나는 회의 중 겹치지 않는 회의를 선택하는 그리디 알고리즘으로 접근한다. 회의 끝 시간을 기준으로 정렬하면, 끝나는 시간이 k인 가장 앞선 회의보다 이후 k'시간 에 끝나는 회의를 선택했을 때, 앞으로 회의에 추가적으로 사용할 수 있는 시간이 항상 더 짧아지기 때문이다. 따라서 항상 일찍 끝나는 회의를 그리디하게 선택하는 것이 최적의 답이다.

2. 구현

n = int(input())
time = [[0, 0] for _ in range(n)]

for i in range(n):
    tmp = input().split()
    start, end = int(tmp[0]), (int)(tmp[1])
    time[i][0] = start
    time[i][1] = end

time.sort(key=lambda x:x[1])

res = [time[0]]
idx = 0

for i in range(n):
    if res[idx][1] <= time[i][0]:
        res.append(time[i])
        idx += 1

print(len(res))