Algorithm/๐ Concept
[์๋ฃ๊ตฌ์กฐ] ๋จ์/์ํ/์ด์ค ์ฐ๊ฒฐ๋ฆฌ์คํธ(Linked List) ๊ตฌํ - ํ์ด์ฌ(Python)
์ฐ๊ฒฐ๋ฆฌ์คํธ(Linked List) ๋ค์ ์์์ ์๋ฃ๊ฐ ์๋ ์์น๋ฅผ ๋ฐ์ดํฐ์ ํฌํจ์ํค๋ ๋ฐฉ์์ผ๋ก ์๋ฃ๋ฅผ ์ ์ฅํ๋ ์ ํ ์๋ฃ๊ตฌ์กฐ ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ Node๋ก ๊ตฌ์ฑ๋์ด ์๊ณ , Node ์์๋ Data์ Link(Next)๋ก ๊ตฌ์ฑ Data: ๋ฐ์ดํฐ ๊ฐ ์ ์ฅ Link(Next): ๋ค์ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํด ์ฅ์ ๋ฐ์ดํฐ ์ถ๊ฐ, ์ญ์ ์ ์ ๋ฆฌ ๋ฐฐ์ด: ์๊ฐ๋ณต์ก๋ O(n) ์ฐ๊ฒฐ๋ฆฌ์คํธ: ์๊ฐ๋ณต์ก๋ O(1) ๊ณต๊ฐ๋ณต์ก๋ ์ธก๋ฉด์์ ์ ๋ฆฌ (๋ฐฐ์ด์ฒ๋ผ ์ฐ์๋ ๊ณต๊ฐ์ ํ ๋นํ์ง ์๊ณ ํ์ ์์๋ง ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋์ ํ ๋นํ๊ธฐ ๋๋ฌธ) ๋ฉ๋ชจ๋ฆฌ ๋์ X ์ ์ฐํ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ๋จ์ ๋ฐ์ดํฐ ํ์ ์ ๋ถ๋ฆฌ (๋ฐ์ดํฐ์ ๋ ผ๋ฆฌ์ ์ ์ฅ ์์์ ๋ฌผ๋ฆฌ์ ์ ์ฅ ์์๊ฐ ์ผ์นํ์ง ์์ ์ธ๋ฑ์ค ์ ๊ทผ์ด ์๋ ์ ์ฒด๋ฅผ ์ํํด์ผ ํ๊ธฐ ๋๋ฌธ) ๋ฐฐ์ด: ์๊ฐ๋ณต์ก๋ O(1) ์ฐ๊ฒฐ๋ฆฌ์คํธ: ์๊ฐ๋ณต์ก๋ O..
[์๋ฃ๊ตฌ์กฐ] ์ฐ์ ์์ ํ(Priority Queue/Heapq) ๊ตฌํ - ํ์ด์ฌ(Python)
์ฐ์ ์์ ํ๋? ์ฐ์ ์์ ํ๋ ๋จผ์ ๋ค์ด์จ ๋ฐ์ดํฐ๊ฐ ๋จผ์ ์ฒ๋ฆฌ๋๋ ์ผ๋ฐ์ ์ธ ํ์ ๋ฌ๋ฆฌ, ์ฐ์ ์์๊ฐ ๋์ ๋ฐ์ดํฐ๋ถํฐ ์ฒ๋ฆฌ๋๋ ์๋ฃ๊ตฌ์กฐ์ด๋ค. ๋ฐฐ์ด, ์ฐ๊ฒฐ๋ฆฌ์คํธ, ํ(Heap)์ผ๋ก ๋ชจ๋ ๊ตฌํํ ์ ์์ง๋ง ์ผ๋ฐ์ ์ผ๋ก๋ ์๊ฐ๋ณต์ก๋๊ฐ ์ ์ ํ(Heap)์ ์ฌ์ฉํ๋ค. ํ(Heap) ์ต์๊ฐ, ์ต๋๊ฐ์ ์ฐพ์๋ด๋ ์ฐ์ฐ์ ๋น ๋ฅด๊ฒํ๊ธฐ ์ํด ๊ณ ์๋ ์์ ์ด์ง ํธ๋ฆฌ์ ์ผ์ข ์ธ ์๋ฃ๊ตฌ์กฐ์ด๋ค. ํ์ ์ต์ ํ๊ณผ ์ต๋ ํ์ผ๋ก ๊ตฌ๋ถํ ์ ์๋ค. - ์ต์ ํ: ๋ฃจํธ๋ ธ๋๊ฐ ๊ฐ์ฅ ์์ ๊ฐ์ ๊ฐ์ง๋ฉฐ, ํญ์ ๋ถ๋ชจ๋ ธ๋๋ ์์๋ ธ๋๋ณด๋ค ์์ ๊ฐ์ ๊ฐ์ง - ์ต๋ ํ: ๋ฃจํธ๋ ธ๋๊ฐ ๊ฐ์ฅ ํฐ ๊ฐ์ ๊ฐ์ง๋ฉฐ, ํญ์ ๋ถ๋ชจ๋ ธ๋๋ ์์๋ ธ๋๋ณด๋ค ํฐ ๊ฐ์ ๊ฐ์ง ์ฐ์ ์์ ํ ๊ตฌํ (ํ์ด์ฌ) - PriorityQueue from queue import PriorityQueue ..
[์๊ณ ๋ฆฌ์ฆ] ๊ธฐ์ค์ ๋ฐ๋ผ ์ ๋ ฌ(sort/sorted) - ํ์ด์ฌ(Python)
โ sort - ๋ฆฌ์คํธ.sort() - ๋ฐํ ๊ฐ ์์ด ์ค๋ฆ์ฐจ์(๊ธฐ๋ณธ๊ฐ)์ผ๋ก ์ ๋ ฌ - ์๋์ ๋ฆฌ์คํธ๊ฐ ์ ๋ ฌ๋ ๊ฐ์ผ๋ก ๋ณํ array = [5, 2, 4, 3, 1] array.sort() print(array) # [1, 2, 3, 4, 5] โ sorted - sorted(๋ฆฌ์คํธ) - ์ค๋ฆ์ฐจ์(๊ธฐ๋ณธ๊ฐ)์ผ๋ก ์ ๋ ฌ๋ ๋ฆฌ์คํธ ๋ฐํ - ์๋์ ๋ฆฌ์คํธ๋ ๋ณํ X array = [5, 2, 4, 3, 1] sorted_array = sorted(array) print(sorted_array) # [1, 2, 3, 4, 5] parameter 1. reverse - ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ array.sort(reverse=True) # [5, 4, 3, 2, 1] sorted_array = sorted(array, rever..
[์๊ณ ๋ฆฌ์ฆ] ๋ฒ์๋ฅผ ๋ฐ์ฉ ์ขํ๊ฐ๋ ์ด์ง ํ์ - ํ์ด์ฌ(Python)
์์ฐจ ํ์ ๋ฆฌ์คํธ ์์ ์๋ ํน์ ํ ๋ฐ์ดํฐ๋ฅผ ์ฐพ๊ธฐ ์ํด ์์์๋ถํฐ ๋ฐ์ดํฐ๋ฅผ ํ๋์ฉ ์ฐจ๋ก๋๋ก ํ์ธํ๋ ๋ฐฉ๋ฒ ๋ฆฌ์คํธ์ ์ฒซ ๋ฒ์งธ ์์๋ถํฐ ์ฐพ๊ณ ์ ํ๋ ๋ฐ์ดํฐ์ ์ผ์นํ๋์ง ํ์ธํ์ฌ ์ผ์นํ๋ฉด ํ์ ์ข ๋ฃ, ์ผ์นํ์ง ์์ผ๋ฉด ๋ค์ ์์๋ก ์ด๋ํ๋ค. # ์์ฐจ ํ์ def sequential_search(n, target, array): for i in range(n): if array[i] == target: return i+1 # ํ์ฌ ์์น ๋ฐํ (-๋ฒ์งธ) array = ['S', 'T', 'A', 'R'] # ์์ ์ง์ ๋ฆฌ์คํธ print("๋ฆฌ์คํธ ์ A์ ์์น๋ " + sequential_search(len(array), 'A', array) + "์ ๋๋ค.") # ํ์ ๊ฒฐ๊ณผ ์ถ๋ ฅ ์ด์ง ํ์ ๋ฆฌ์คํธ ๋ด์ ๋ฐ์ดํฐ๊ฐ ์ ๋ ฌ..
[์๊ณ ๋ฆฌ์ฆ] ๊ทธ๋ํ ํ์์ ์ํ DFS์ BFS - ํ์ด์ฌ(Python)
๊ทธ๋ํ ํํ ๊ทธ๋ํ๋ ๋ ธ๋(Node)์ ๊ฐ์ (Edge)๋ก ํํ๋๋ฉฐ ์ด๋ ๋ ธ๋๋ฅผ ์ ์ (Vertex)๋ผ๊ณ ๋ ํ๋ค. ํ๋ก๊ทธ๋๋ฐ์์ ๊ทธ๋ํ๋ '์ธ์ ํ๋ ฌ'๊ณผ '์ธ์ ๋ฆฌ์คํธ' 2๊ฐ์ง ๋ฐฉ์์ผ๋ก ํํํ ์ ์๋ค. ์ธ์ ํ๋ ฌ : 2์ฐจ์ ๋ฐฐ์ด๋ก ๊ทธ๋ํ์ ์ฐ๊ฒฐ๊ด๊ณ๋ฅผ ํํํ๋ ๋ฐฉ์ - ๊ฐ ๋ ธ๋๊ฐ ์ฐ๊ฒฐ๋ ํํ๋ฅผ ๊ธฐ๋กํ์ฌ ์ ์ฅ INF = 999999999 # ๋ฌดํ์ ๋น์ฉ ์ ์ธ # 2์ฐจ์ ๋ฆฌ์คํธ๋ฅผ ํตํด ์ธ์ ํ๋ ฌ ํํ graph = [ [0, 7, 5], [7, 0, INF], [5, INF, 0] ] print(graph) ์ธ์ ๋ฆฌ์คํธ : ๋ฆฌ์คํธ๋ก ๊ทธ๋ํ์ ์ฐ๊ฒฐ๊ด๊ณ๋ฅผ ํํํ๋ ๋ฐฉ์ - ๋ชจ๋ ๋ ธ๋์ ์ฐ๊ฒฐ๋ ๋ ธ๋์ ๋ํ ์ ๋ณด๋ฅผ ์ฐจ๋ก๋๋ก ์ฐ๊ฒฐํ์ฌ ์ ์ฅ # ํ์ด 3๊ฐ์ธ 2์ฐจ์ ๋ฆฌ์คํธ๋ก ์ธ์ ๋ฆฌ์คํธ ํํ graph = [[] for _..
[์๋ฃ๊ตฌ์กฐ] ์คํ(Stack)๊ณผ ํ(Queue) - ํ์ด์ฌ(Python)
์คํ(Stack) ๋์ค์ ๋ฃ์ ๋ฐ์ดํฐ๋ฅผ ๋จผ์ ๋นผ๋ ํ์ ์ ์ถ(LIFO - Last In First Out) ๊ตฌ์กฐ ex) ๋ฐ์ค ์๊ธฐ, ํธ๋ญ์ ๋ฌผ๊ฑด ๋ฃ๊ธฐ ํ์ด์ฌ ๊ธฐ๋ณธ ๋ฆฌ์คํธ์์ append()์ pop() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ๊ตฌํ stack = [] stack.append(1) # stack: [1] stack.append(2) # stack: [1, 2] stack.append(3) # stack: [1, 2, 3] stack.append(4) # stack: [1, 2, 3, 4] stack.pop() # stack: [1, 2, 3] stack.pop() # stack: [1, 2] stack.append(3) # stack: [1, 2, 3] stack.pop() # stack: [1, 2] ํ(Queu..