728x90 python38 [TIL] Algorithm - ๋ค์ต์คํธ๋ผ + ๊ทธ๋ํ ๋ฌธ์ ํ์ด(BFS) 1. ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ(Dijkstra algorithm) ๋ชจ๋ ๊ฐ์ ์ ๋ํ ๊ฐ์ค์น๊ฐ ํญ์ 0์ด์์์ ๊ฐ์ ํ๊ณ ๋ ๊ผญ์ง์ ๊ฐ์ ๊ฐ์ฅ ์งง์ ๊ฒฝ๋ก๋ฅผ ์ฐพ๋ ์๊ณ ๋ฆฌ์ฆ ๊ฐ์ ์ํ(Edge Relaxation) ์์ ์ ์ s์์ ๋ค๋ฅธ ์ ์ v๊น์ง์ ์ด๊ธฐ ๊ฑฐ๋ฆฌ ๊ฐ์ ๋ถ์ฌํ๊ณ ๋จ๊ณ๋ฅผ ๊ฑฐ๋ญํ์ฌ ๊ฐ์ ์ํค๋ ๊ฒ ๊ฐ์ (u, v)๋ฅผ ์ํํ๋ ๊ณผ์ u๋ฅผ ํตํด v๊น์ง ๊ฐ๋ ์ง๊ธ๊น์ง ๋ฐ๊ฒฌ๋ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ๊ฐ์ ํ ์ ์๋์ง ๊ฒ์ฌ ๊ฐ์ ํ ์ ์๋ค๋ฉด, v์ ์ต๋จ ๊ฒฝ๋ก ์ถ์ ๊ฐ์ ๊ฐฑ์ ํ๋ค. ์๊ฐ๋ณต์ก๋ O(|E| + |V|log|V|) https://ko.wikipedia.org/wiki/๋ฐ์ดํฌ์คํธ๋ผ_์๊ณ ๋ฆฌ์ฆ 1. ๋ค์ต์คํธ๋ผ๋ฅผ ์ด์ฉํ ๋ฌธ์ ํ์ด 1. 1916๋ฒ - ์ต์๋น์ฉ ๊ตฌํ๊ธฐ import sys import heapq N =.. 2023. 4. 24. [TIL] ๊ทธ๋ํ ๋ฌธ์ ๋ฌธ์ ํ์ด 1. ๊ทธ๋ํ ๋ฌธ์ ํ์ด(DFS) 1. 1707๋ฒ - ์ด๋ถ ๊ทธ๋ํ 1. ์ด๋ถ ๊ทธ๋ํ(bipartite graph)๋? ๋ชจ๋ ์ ์ ์ ๋๊ฐ์ง ์์ผ๋ก ์น ํ๋, ๋ชจ๋ ๋ณ์ด ๋๊ฐ์ง ์์ ์ ์ ์ ํฌํจํ๋๋ก ํ๋ ๊ทธ๋ํ ์์ ์ด๋ฏธ์ง์์ ๋ณด๋ฉด ๋ชจ๋ ๊ฐ์ ์ด ๋นจ๊ฐ, ์ด๋ก ์ ์ ์ ๊ฐ์ง๊ณ ์๋ค. ์ฆ, ๊ทธ๋ํ์ ๋ชจ๋ ์ ์ ์ด ๋ ๊ทธ๋ฃน์ผ๋ก ๋๋ ์ง๊ณ ์๋ก ๋ค๋ฅธ ๊ทธ๋ฃน์ ์ ์ ์ด ๊ฐ์ ์ผ๋ก ์ฐ๊ฒฐ๋์ด ์๋ ๊ทธ๋ํ https://gmlwjd9405.github.io/2018/08/23/algorithm-bipartite-graph.html 2. ๋ฐฑ์ค ์ ์ถ ํ์ด(DFS - ๋ฐ๋ณต) import sys K = int(sys.stdin.readline()) # dfs ๋ฐ๋ณต๋ฌธ์ผ๋ก ๊ตฌํ def dfs(g, n) : # n ์์ ์ ์ stack.. 2023. 4. 22. [TIL] Algorithm - ์ต์ ์ ์ฅ ํธ๋ฆฌ + ๊ทธ๋ํ ๊ธฐ๋ณธ ๋ฌธ์ ํ์ด 1. ๊ทธ๋ํ ๊ธฐ๋ณธ ๋ฌธ์ ํ์ด 1. 5639๋ฒ - ์ด์ง ๊ฒ์ ํธ๋ฆฌ import sys sys.setrecursionlimit(10**6) nums = [] # ์ ๋ ฅ์ด ๋์ด์ ๋ค์ด์ค์ง ์์ ๋ ์ค๋ฅ ๋ฐ์ # ์ค๋ฅ๊ฐ ๋ํ๋๋ฉด while๋ฌธ ์ข ๋ฃ while True : try : nums.append(int(sys.stdin.readline())) except : break # nums์ ์์ ์ธ๋ฑ์ค = start # nums์ ๋ ์ธ๋ฑ์ค = end def post(start, end) : if start == end : # start์ end๊ฐ ๊ฐ์ ๊ฒฝ์ฐ # ํ๊ฐ์ง ๊ฒฝ์ฐ๋ง ์์ผ๋ ์ถ๋ ฅ print(nums[start]) return root = nums[start] # ํ์ฌ ๋ฃจํธ ๋ ธ๋ mid = start for.. 2023. 4. 21. [TIL] Graph + ํธ๋ฆฌ ์ํ 1. ๋ฌธ์ ํ์ด ์ ๋ฆฌ 1. 16120๋ฒ - PPAP import sys s = sys.stdin.readline().strip() stack = [] ppap = ["P", "P", "A", "P"] for i in s : stack.append(i) # ํ์ฌ ์คํ์ PPAP๊ฐ ์์ผ๋ฉด 3๋ฒ popํ์ฌ P๋ง ๋จ๊ธด๋ค. if stack[-4:] == ppap : stack.pop() stack.pop() stack.pop() # ์ต์ข ์ ์ผ๋ก P๋ง ๋จ์ ๊ฒฝ์ฐ if stack == ["P"] : print("PPAP") else : print("NP") ๋ฌธ์ ์์ ์กฐ๊ฑด์ ๋ณด๋ฉด PPAP ๋ P๋ก ๋ฐ๊ฟ ์ ์๊ณ P ๋ฅผ PPAP๋ก ๋ฐ๊ฟ ์ ์๋ค. ์ฆ, ์ด๋ค ๋ฌธ์์ด์ ๋ฐ๊ณ ์ด ๋ฌธ์์ด์ด PPAP ๋ฌธ์์ด์ธ์ง ํ์ธํ๋ ค๋ฉด PPAP.. 2023. 4. 20. [TIL] ์คํ๊ณ์ฐ๊ธฐ + Hashing3 1. ์คํ์ ์ด์ฉํ ๊ณ์ฐ๊ธฐ 1. ์ ํ๊ธฐ๋ฒ ์ ์ ํ๊ธฐ๋ฒ(prefix, ํด๋๋ ํ๊ธฐ๋ฒ) : ์ฐ์ฐ์๋ฅผ ์ฐ์ฐ ๋์์ ์์ ์ฐ๋ ์ฐ์ฐ ํ๊ธฐ๋ฒ ex) *+234 ์ฅ์ : ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ์ธํฐํ๋ฆฌํฐ์ ์ํด ์ํ์ ํํ์์ ๋ํ ๋ฌธ๋ฒ์ผ๋ก์จ ์ฌ์ฉ๋๋ ๊ฒฝ์ฐ, ๊ณง๋ฐ๋ก ์ถ์ ๋ฌธ๋ฒ ํธ๋ฆฌ๋ก ๊ตฌ๋ฌธ ๋ถ์๋๋ฉฐ, ์ฌ์ค ๋์ผํ๊ฒ ์ ๋จ์ฌ ํจ์๋ฅผ ์ ์ํ ์ ์๋ค. ๋จ์ : ์ฌ๋์ ๋์ผ๋ก ์ฝ๊ฒ ์ดํดํ๊ฑฐ๋ ๊ณ์ฐํ๊ธฐ ํ๋ค๋ค. ์ค์ ํ๊ธฐ๋ฒ(infix) : ์ฐ์ฐ ๋์ ์ฌ์ด์ ์ฐ์ฐ์๋ฅผ ์ฐ๋ ์ฐ์ฐ ํ๊ธฐ๋ฒ ex) (2+3)*4 ์ฅ์ : ์ฌ๋์๊ฒ ์น์ํ๋ค. ๋จ์ : ์ฐ์ ์์ ๊ท์น์ ๋ฐ๋ผ ์ฐ์ฐ ์์๋ฅผ ๊ฒฐ์ ํ์ฌ ๊ดํธ๋ก ์ฐ์ฐ์ด ์ํ๋๋ ์๋๋ ์์๋ฅผ ๊ฐ๋ฆฌํค๋๋ฐ ํ์์ ์ด๋ค. ์ปดํจํฐ๋ก ๊ตฌ๋ฌธ ๋ถ์ํ๊ธฐ ์ด๋ ต๋ค. ํ์ ํ๊ธฐ๋ฒ(postfix) : ์ฐ์ฐ์๋ฅผ ์ฐ์ฐ ๋์์.. 2023. 4. 19. [TIL] ๋ถํ ์ ๋ณต ์ฐ์ต๋ฌธ์ ํ์ด + Hashing2 1. ๋ถํ ์ ๋ณต ์ฐ์ต๋ฌธ์ 1. 10830๋ฒ - ํ๋ ฌ ์ ๊ณฑ import sys N, B = map(int, sys.stdin.readline().split()) p = [list(map(int, sys.stdin.readline().split())) for _ in range(N)] # ๋ ํ๋ ฌ์ ๊ณฑํ๋ ํจ์ def mul (a, b) : result = [[0] * N for _ in range(N)] for r in range(N) : for c in range(N) : for i in range(N) : result[r][c] += a[r][i] * b[i][c] result[r][c] %= 1000 return result # ์ ๊ณฑ๊ทผ์ ๋ถํ ํ๋ ํจ์ def getResult(p, b) : if b .. 2023. 4. 18. [TIL] ์๋ฃ๊ตฌ์กฐ - ์ฐ์ ์์ ํ 1. ์ฐ์ ์์ ํ(Priority Queue) ์ฐ์ ์์ ํ๋ ์ถ์์ ์ธ ๊ฐ๋ ์ผ๋ก ํ์ด๋ ๋ค์ํ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ ์ด์ฉํด ๊ตฌํ๋๋ค. ๊ฐ ์์๋ค์ ์ฐ์ ์์๋ฅผ ๊ฐ๊ณ ์ฐ์ ์์ ํ์์ ๋์ ์ฐ์ ์์๋ฅผ ๊ฐ์ง ์์๊ฐ ๋ฎ์ ์ฐ์ ์์๋ฅผ ๊ฐ์ง ์์๋ณด๋ค ๋จผ์ ์ฒ๋ฆฌ๋๋ค. ์ฆ, ์์์ ์์๋ก ์ฝ์ ๋์ง๋ง, ์ ํด์ง ์์๋ก ์ญ์ ๋๋ค. push() : ํ๋์ ์์๋ฅผ ์ฐ์ ์์๋ฅผ ์ง์ ํ์ฌ ์ถ๊ฐ pop() : ๊ฐ์ฅ ๋์ ์ฐ์ ์์๋ฅผ ๊ฐ์ง ์์๋ฅผ ํ์์ ์ ๊ฑฐ ํ ๋ฐํ 1. ์ฐ์ ์์ ํ ๊ตฌํํด๋ณด๊ธฐ(์ต์ํ์ผ๋ก ๊ตฌํ) class PriorityQueue : def __init__(self) : # ์ฌ๊ธฐ์ ์ฌ์ฉํ ๋ฆฌ์คํธ๋ ์์ ์ด์งํธ๋ฆฌ๋ฅผ ๊ตฌํ # 0๋ฒ ์ธ๋ฑ์ค๋ฅผ ์ฌ์ฉํ์ง ์๊ธฐ ์ํด 0๋ฒ์ None ์ฝ์ self.items = [None] def __len__.. 2023. 4. 17. [TIL] ๋ฐฑ์ค ํ์ด ์ ๋ฆฌ2 โป ํ์ผ์ ํ์ง ์๊ณ ๋๊ธด ๋ฌธ์ ํ์ด โป 1. 8983๋ฒ - ์ฌ๋ฅ๊พผ import sys # M : ์ฌ๋ ๊ฐ์ # N : ๋๋ฌผ์ ์ # L : ์ฌ์ ๊ฑฐ๋ฆฌ M, N, L = map(int, sys.stdin.readline().split()) gun = list(map(int, sys.stdin.readline().split())) # ์ฌ๋์ ์์น gun.sort() animal = [list(map(int, sys.stdin.readline().split())) for _ in range(N)] # ๋๋ฌผ๋ค์ ์์น def hunt(gun, animal) : count = 0 # ๋๋ฌผ์ ์์น๋ฅผ ๋ฐ๋ณต for x, y in animal : min_idx, max_idx = 0, len(gun)-1 # ๋๋ฌผ์ ์ก์ .. 2023. 4. 16. [TIL] ์๋ฃ๊ตฌ์กฐ - Queue + Hashing์ด๋? 1. ์คํ ์ฐ์ต ๋ฌธ์ (10000๋ฒ - ์ ์์ญ) import sys # https://wonyoung2257.tistory.com/79 ์ฐธ๊ณ N = int(sys.stdin.readline()) circles = [] for i in range(N) : x, r = map(int, sys.stdin.readline().split()) circles.append((x-r, '(')) # ์ค์ ์ ๊ธฐ์ค์ผ๋ก ์ผ์ชฝ์ ์๋ ์ขํ circles.append((x+r, ')')) # ์ค์ ์ ๊ธฐ์ค์ผ๋ก ์ค๋ฅธ์ชฝ์ ์๋ ์ขํ # x์ขํ ์์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ & ๊ฐ์ ๊ฒฝ์ฐ ')' ๋ฌธ์๋ฅผ ๊ฐ์ง ๊ฐ์ด ์์ผ๋ก ์ค๋๋ก # ์์คํค ์ฝ๋ : '(' = 72, ')' = 73 circles.sort(key = lambda x: (x[0].. 2023. 4. 15. [TIL] Algorithm - ๋ถํ ์ ๋ณต + ์คํ 1. ์ด๋ถ ํ์ ๊ฐ๋ ์ ์ด์ฉํ ๋ฌธ์ ํ์ด (11053๋ฒ - ๊ฐ์ฅ ๊ธด ์ฆ๊ฐํ๋ ๋ถ๋ถ ์์ด) import sys # A์ ํฌ๊ธฐ N = int(sys.stdin.readline()) # ์์ด A = list(map(int, sys.stdin.readline().split())) # https://namu.wiki/w/์ต์ฅ%20์ฆ๊ฐ%20๋ถ๋ถ%20์์ด#s-3.2 ์ฐธ๊ณ def LIS() : # d[i] = A[i]๋ฅผ ๋ง์ง๋ง ๊ฐ์ผ๋ก ๊ฐ์ง๋ ๊ฐ์ฅ ๊ธด ์ฆ๊ฐ๋ถ๋ถ ์์ด ๊ธธ์ด d = [A[0]] for i in range(1, len(A)) : # d์ ์ ์ฅ๋ ๊ฐ์ฅ ๋ง์ง๋ง ๊ฐ๋ณด๋ค ํ์ฌ ๊ฐ์ด ํฌ๋ฉด if d[-1] 0 ~ len(d)-1 ์ฌ์ด.. 2023. 4. 14. [TIL] Algorithm - ์ด๋ถํ์(Binary Search) + ์ง์ ์ฃผ์ ํ ์ด๋ธ์ด๋? 1. ์ด๋ถํ์ ๋๋ ์ด์ง๊ฒ์ ์ ๋ ฌ๋ ๋ฆฌ์คํธ๋ฅผ ๊ณ์ํด์ ๋ฐ์ผ๋ก ๋๋ ์ํ๋ ๊ฐ์ ์์น๋ฅผ์ฐพ๋ ์๊ณ ๋ฆฌ์ฆ Wiki ์ฅ์ : ๊ฒ์์ด ๋ฐ๋ณต๋ ๋๋ง๋ค ๋ชฉํ๊ฐ์ ์ฐพ์ ํ๋ฅ ์ด 2๋ฐฐ๊ฐ ๋๋ฏ๋ก ์๋๊ฐ ๋น ๋ฅด๋ค. → ์๊ฐ๋ณต์ก๋ O(logN) ๋จ์ : ์ ๋ ฌ๋ ๋ฆฌ์คํธ์์๋ง ์ฌ์ฉ์ด ๊ฐ๋ฅํ๋ค. ์ด์ง ํ์ ๊ณผ์ ์ฐธ๊ณ ์ฌ์ดํธ https://blog.penjee.com/binary-vs-linear-search-animated-gifs/ Binary Vs Linear Search Through Animated Gifs Average Case Worst Case Binary Search Best Case Binary Search If you're into searching, maybe you're also into sorting! Check.. 2023. 4. 13. [TIL] ๋ฐฑ์ค ํ์ด ์ ๋ฆฌ โป ์ํ์ ์๋๊ณ Week01์ฃผ์ฐจ์ ๊ณต๋ถํ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ฐ์ตํ๋ค. โป 1. ์์ ํ์ ์ฐ์ต ๋ฌธ์ (14888๋ฒ - ์ฐ์ฐ์ ๋ผ์๋ฃ๊ธฐ) import sys N = int(sys.stdin.readline()) nums = list(map(int, sys.stdin.readline().split())) plus, minus, multiply, divide = map(int, sys.stdin.readline().split()) # sys์ ๊ฐ์ฅ ํฐ์๋ฅผ ์ ์ฅ resultMax = -sys.maxsize resultMin = sys.maxsize ''' count : ํ์ฌ ์ ๊ทผํ๋ nums ์ธ๋ฑ์ค total : ์์ ์ฐ์ฐ ๊ฒฐ๊ณผ plus, minus, multiply, divide : ๊ฐ ์ฐ์ฐ์ด ๊ฐ์ง๊ณ ์๋ ๊ฐ์ .. 2023. 4. 12. [TIL] ๋ฐฑ์ค ์ฝ๋ ํ์ด & Computer System 1. ๋ฐฑ์ค - ์ด๋ ค์ ๋ ๋ฌธ์ ์ ๋ฆฌ & ํ์ด ๊ณต๋ถ 1. N-Queen (9663๋ฒ) import sys n = int(sys.stdin.readline()) # row ๋ฆฌ์คํธ์์ ์ธ๋ฑ์ค = ํ๋ฒํธ / row[i] ๊ฐ์ ์ด๋ฒํธ row = [0] * n result = 0 # https://seongonion.tistory.com/103 ์ฐธ๊ณ # https://lighter.tistory.com/m/26 ์ฐธ๊ณ # ํธ์ ๋์ ์ ์๋ ์์น์ธ์ง ์ฌ๋ถ ํ๋จ def isPromising(x) : for i in range(x) : ''' 1. ๊ฐ์ ์ด์ ์๋์ง ํ์ธ row[x] == row[i] : x๋ฒ ํ๊ณผ i๋ฒ ํ์ ๋์ฌ์๋ ํธ์ ์ด ๋ฒํธ๊ฐ ๊ฐ์ ๊ฒฝ์ฐ 2. ๋๊ฐ์ ์ ์กด์ฌํ๋์ง ํ์ธ row[x]-row[i] : ์ธ.. 2023. 4. 11. [TIL] Algorithm - ์ ๋ ฌ3 + git ์ฌ์ฉ๋ฒ ์ ๋ฆฌ 1. ๋ณํฉ ์ ๋ ฌ(merge sort) ๋ฐฐ์ด์ ์๋ถ๋ถ๊ณผ ๋ท๋ถ๋ถ์ ๋ ๊ทธ๋ฃน์ผ๋ก ๋๋์ด ๊ฐ๊ฐ ์ ๋ ฌํ ํ ๋ณํฉํ๋ ์์ ์ ๋ฐ๋ณตํ๋ ์๊ณ ๋ฆฌ์ฆ # ๋ณํฉ ์ ๋ ฌ ๊ตฌํ def merge_sort(list) : # ์ฌ๊ท์ ์ผ๋ก ์คํํ ํจ์ def _merge_sort(list, left, right) : if left < right : middle = (left + right) // 2 _merge_sort(list, left, middle) # ๋ฐฐ์ด์ ์๋ถ๋ถ ์ ๋ ฌ _merge_sort(list, middle+1, right) # ๋ฐฐ์ด์ ๋ท๋ถ๋ถ ์ ๋ ฌ ''' ์์์ ์ด๋ฏธ ์ ๋ ฌ๋ ๋ฐฐ์ด 2๊ฐ๋ฅผ ๋ณํฉํ๊ธฐ ์ํ ๋ณ์๋ค p : ํ์ฌ buff๊ฐ ์ฑ์์ ธ ์๋ ์ ๋๋ฅผ ์ ์ฅํ๋ ๋ณ์ / ์ฆ, buff[p-1]๊น์ง ์ฑ์์ ธ์๋ค. j : ๋ณํฉํ .. 2023. 4. 10. [TIL] Algorithm - ์ ๋ ฌ2 1. ์๊ฐ ๋ณต์ก๋ ํน์ ์๊ณ ๋ฆฌ์ฆ์ด ์ด๋ค ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ Big-O(๋น -์ค) ํ๊ธฐ๋ฒ : ์ต์ ์ ๊ฒฝ์ฐ๋ฅผ ๊ณ์ฐํ๋ ๋ฐฉ์ Big-O description $$ O\left ( 1 \right ) $$ ์ ๋ ฅ ๋ฐ์ดํฐ์ ํฌ๊ธฐ์ ์๊ด์์ด ์ธ์ ๋ ์ผ์ ํ ์๊ฐ์ด ๊ฑธ๋ฆฐ๋ค. $$ O\left ( log_{2}n \right ) $$ ์ ๋ ฅ๋ฐ์ดํฐ์ ํฌ๊ธฐ๊ฐ ์ปค์ง์๋ก ์ฒ๋ฆฌ์๊ฐ์ด ๋ก๊ทธ๋งํผ ์งง์์ง๋ค. $$ O\left ( n \right ) $$ ์ ๋ ฅ๋ฐ์ดํฐ์ ํฌ๊ธฐ์ ๋น๋กํ์ฌ ์๊ฐ์ด ์ฆ๊ฐํ๋ค. $$ O\left ( n log_{2}n \right ) $$ ๋ฐ์ดํฐ๊ฐ ๋ง์์ง์๋ก ๋ก๊ทธ๋ฐฐ ๋ฐฐ๋งํผ ์๊ฐ์ด ์ฆ๊ฐํ๋ค. $$ O\left ( n^{2} \right ) $$ ๋ฐ์ดํฐ๊ฐ ๋ง์์ง์๋ก ๊ธ์์ ์ผ๋ก ์๊ฐ์ด ์ฆ๊ฐํ๋ค. $$ O\left.. 2023. 4. 9. [TIL] Algorithm - ์ ๋ ฌ โฐ 2023.04.08 โฐ 1. Sorting key ๋ฅผ ํญ๋ชฉ ๊ฐ์ ๋์ ๊ด๊ณ์ ๋ฐ๋ผ ๋ฐ์ดํฐ ์งํฉ์ ์ผ์ ํ ์์๋ก ๋ฐ๊พธ์ด ๋์ด๋๋ ์์ ๋ฐ์ดํฐ๋ฅผ ๊ตํ, ์ ํ, ์ฝ์ ํ๋ฉด์ ์ ๋ ฌ์ ์๋ฃํ๋ค. โ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ์์ ์ฑ โ ๊ฐ์ด ๊ฐ์ ์์์ ์์๋ ์ ๋ ฌํ ํ์๋ ์ ์ง๋๋ฉด ์์ ์ ์ธ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ์์ ์ ์ธ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ ๋ฒ๋ธ ์ ๋ ฌ, ์ฝ์ ์ ๋ ฌ, ๋ณํฉ ์ ๋ ฌ, ๋์ ์ ๋ ฌ(๊ณ์ ์ ๋ ฌ) ์์ ์ ์ด์ง ์๋ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ ์ ํ ์ ๋ ฌ, ํต ์ ๋ ฌ, ํ ์ ๋ ฌ, 2. ๋ฒ๋ธ ์ ๋ ฌ(bubble sort) ์ด์ํ ๋ ์์์ ๋์ ๊ด๊ณ๋ฅผ ๋น๊ตํ์ฌ ํ์์ ๋ฐ๋ผ ๊ตํ์ ๋ฐ๋ณตํ๋ ์๊ณ ๋ฆฌ์ฆ ( = ๋จ์ ๊ตํ ์ ๋ ฌ ) ์๊ฐ๋ณต์ก๋ O(n^2) 1. ๊ธฐ๋ณธ ๊ตฌํ # ๊ธฐ๋ณธ ๋ฒ๋ธ ์ ๋ ฌ def bubble_sort(list) : n = len(list).. 2023. 4. 8. [Python] Stack๊ณผ Queue์ฌ์ฉํด๋ณด๊ธฐ 1. Stack LIFO(Last In First Out) = FILO(First In Last Out) ๋์ค์ ๋ค์ด์จ ๊ฐ์ด ๋จผ์ ๋๊ฐ๋ ์๋ฃ๊ตฌ์กฐ โ list๋ฅผ ์ด์ฉํ์ฌ ๊ฐ๋จํ๊ฒ ์คํ ์ฌ์ฉํด๋ณด๊ธฐ โ # ํ์ด์ฌ์์ ์คํ์ ๋ฆฌ์คํธ๋ก ๊ตฌํํ๋ค. stack = [] # ์คํ์ ๊ฐ ์ถ๊ฐํ๊ธฐ stack.append(1) stack.append(2) stack.append(3) print("stack์ ์ฝ์ ํ ํ : ",stack) # ์คํ์์ ๊ฐ ์ ๊ฑฐํ๊ธฐ print("์ฒซ๋ฒ์งธ pop : ",stack.pop()) print("popํ ํ ์คํ : ", stack) print("๋๋ฒ์งธ pop : ",stack.pop()) print("popํ ํ ์คํ : ", stack) print("์ธ๋ฒ์งธ pop : ",stack... 2023. 3. 21. [Python] ๋ฆฌ์คํธ(List) ๊ฐ๋ ์ ๋ฆฌ https://wikidocs.net/book/1 ์ ํ ํฌ ํ์ด์ฌ ์ด ์ฑ ์ ํ์ด์ฌ์ด๋ ์ธ์ด๋ฅผ ์ฒ์ ์ ํด๋ณด๋ ๋ ์๋ค๊ณผ ํ๋ก๊ทธ๋๋ฐ์ ํ ๋ฒ๋ ํด ๋ณธ์ ์ด ์๋ ์ฌ๋๋ค์ ๋์์ผ๋ก ํ๋ค. ํ๋ก๊ทธ๋๋ฐ์ ํ ๋ ์ฌ์ฉ๋๋ ์ ๋ฌธ์ ์ธ ์ฉ์ด๋ค์ ์๊ธฐ ์ฝ๊ฒ ํ์ด์ … wikidocs.net ๋ฆฌ์คํธ(List) listName = [์์1, ์์2, ์์3, ...] ๋ฆฌ์คํธ๋ฅผ ๋ง๋ค ๋๋ ์์์ ๋ณด๋ ๊ฒ๊ณผ ๊ฐ์ด ๋๊ดํธ([ ])๋ก ๊ฐ์ธ ์ฃผ๊ณ ๊ฐ ์์๊ฐ์ ์ผํ(,)๋ก ๊ตฌ๋ถํด ์ค๋ค. ๋๋ list() ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ์์ฑํ ์ ์๋ค. # list() ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ์์ฑ listFunction = list("python") print(listFunction) # ๋น์ด์๋ ๋ฆฌ์คํธ -> emptyList = list() ๋ก ์์ฑ๊ฐ๋ฅ emp.. 2023. 3. 20. ์ด์ 1 2 3 ๋ค์ 728x90