๐์๊ณ ๋ฆฌ์ฆ/๋ฐฑ์ค
[Python/ํ์ด์ฌ] ๋ฐฑ์ค 1043๋ฒ: ๊ฑฐ์ง๋ง
๋ฌธ์ ํ์ด ์ง์ค์ ์๊ณ ์๋ ์ฌ๋์ ์งํฉ์ knowList ํํฐ์ ์ฐธ์ํ ์ฌ๋์ ์งํฉ์ party party๋ฅผ ์์๋ก ๊ฐ๋ ๋ฐฐ์ด parties 1. ๋ง์ฝ party, knowList์ ๊ต์งํฉ์ด ํ๋๋ผ๋ ์์ผ๋ฉด knowList = knowList.union(party) (ํํฐ์ ์ง์ค์ ์๋ ์ฌ๋์ด ํ ๋ช ์ด๋ผ๋ ์๋ค๋ฉด, ๊ทธ ์ฌ๋์ผ๋ก ์ธํด ํํฐ์ ์ฐธ์ํ ๋ชจ๋ ์ฌ๋์ด ์ง์ค์ ์๊ฒ ๋จ) 2. ์ ๊ณผ์ ์ ํํฐ์ ์๋งํผ ๋ฐ๋ณต why?? 5๊ฐ์ ํํฐ๊ฐ ์๊ณ ์ง์ค์ ์๋ ์ฌ๋์ด A๋ผ๊ณ ๊ฐ์ ํ์. ์ด ๊ฒฝ์ฐ 5๊ฐ์ ํํฐ ์ค A๊ฐ ์ฐธ์ฌํ ํํฐ๊ฐ ์๋์ง ํ์ธํ๋ฉด ๋๋ค. ํ์ธํ๋ ๋์ค A๊ฐ 3๋ฒ์งธ ํํฐ์ ์ฐธ์ฌํ ๊ฒ์ด ๋ฐ๊ฒฌ๋์ด B ์ญ์ ์ง์ค์ ์๊ฒ ๋์๋ค๊ณ ๊ฐ์ ํ์. B์ ๋ํด์๋ ๋ง์ฐฌ๊ฐ์ง๋ก 5๊ฐ์ ํํฐ ์ค B๊ฐ ์ฐธ์ฌํ ํํฐ๊ฐ ์..
[Python/ํ์ด์ฌ] ๋ฐฑ์ค 10830๋ฒ: ํ๋ ฌ ์ ๊ณฑ
๋ฌธ์ ํ์ด ํ๋ ฌ ๊ณฑ์ ์ ๊ตฌํ๋ ํจ์๋ง ์์ฑํ๋ฉด ๋ถํ ์ ๊ณฑ์ ์ด์ฉํ ๊ฑฐ๋ญ์ ๊ณฑ ์๊ณ ๋ฆฌ์ฆ์ ํตํด ์ฝ๊ฒ ํ ์ ์๋ค. ํ๋ ฌ ๊ณฑ์ ์ ๊ตฌํ๋๊ฒ ์ข ๊น๋ค๋ก์ ๋ค... ์ฝ๋ import sys input = sys.stdin.readline sys.setrecursionlimit(10 ** 9) n, b = map(int, input().split()) matrix = [] for _ in range(n): matrix.append(list(map(int, input().split()))) def mulMatrix(m1, m2): tmpArr = [[] for _ in range(n)] for i in range(n): for j in range(n): tmp = 0 for k in range(n): tmp += m1[..
[Python/ํ์ด์ฌ] ๋ฐฑ์ค 13116๋ฒ: 30๋ฒ
๋ฌธ์ ํ์ด ์์ ์ด์งํธ๋ฆฌ ๋ฐ LCA ๋ฌธ์ ์ด๋ค. ์์ ์ด์งํธ๋ฆฌ์ ๋ ๋ฒจ์ log2๋ฅผ ํตํด ๊ตฌํ ์ ์๊ณ ๋ถ๋ชจ๋ /2๋ฅผ ํด์ฃผ๋ฉด ๋๋ค. ์ฆ ๋ ๋ ธ๋์ ๋ ๋ฒจ์ ๊ตฌํ ๋ค, ๋ ๋ฒจ์ ์๋ก ๊ฐ๊ฒ ๋ง์ถฐ์ค ๋ค, ๋ ๋ ธ๋๊ฐ ์๋ก ๊ฐ์ ๋๊น์ง ๊ฐ ๋ ธ๋์ /2๋ฅผ ํด์ฃผ๋ฉด ๋๋ค. (์ด์งํธ๋ฆฌ์ LCA๋ฅผ ๊ณต๋ถํ๋ฉด ์ฝ๊ฒ ํ ์ ์๋ค.) ์ฝ๋ import sys, math input = sys.stdin.readline t = int(input()) def getLevel(n): return math.floor(math.log2(n)) for _ in range(t): a, b = map(int, input().split()) while True: levelA, levelB = getLevel(a), getLevel(b) if levelA..
[Python/ํ์ด์ฌ] ๋ฐฑ์ค 11054๋ฒ: ๊ฐ์ฅ ๊ธด ๋ฐ์ดํ ๋ ๋ถ๋ถ ์์ด
๋ฌธ์ ํ์ด ๊ฐ์ฅ ๊ธด ์ฆ๊ฐํ๋ ๋ถ๋ถ ์์ด๊ณผ ๊ฐ์ฅ ๊ธด ๊ฐ์ํ๋ ๋ถ๋ถ ์์ด์ ๊ตฌํ๋ฉด ๋๋ค. (๋ถ๋ถ ์์ด ์๋ฆฌ์ฆ๋ฅผ ํ์๋ค๋ฉด ์ฝ๊ฒ ํ ์ ์๋ค.) ์ฝ๋ import sys input = sys.stdin.readline n = int(input()) arr = list(map(int, input().split())) dpMax = [1] * n dpMin = [1] * n for i in range(1, n): for j in range(i): if arr[i] > arr[j]: dpMax[i] = max(dpMax[i], dpMax[j] + 1) for i in range(n - 1, -1, -1): for j in range(i, n): if arr[i] > arr[j]: dpMin[i] = max(dpMin..
[Python/ํ์ด์ฌ] ๋ฐฑ์ค 14002๋ฒ: ๊ฐ์ฅ ๊ธด ์ฆ๊ฐํ๋ ๋ถ๋ถ ์์ด 4
๋ฌธ์ ํ์ด ์์ด์ ์ต๋ ํฌ๊ธฐ๊ฐ 1000์ด๋ฏ๋ก N2 ์ผ๋ก ํ๋ฉด ๋๋ค. dp ๊ฐ์ ๊ฐฑ์ ํ๋ ๋ฐฉ๋ฒ๊ณผ ๋์ผํ๊ฒ dp ์์ด๋ ๊ฐฑ์ ํด์ฃผ๋ฉด ๋๋ค. (์๋ ์ฝ๋ ์ฐธ๊ณ ) ์ฝ๋ import sys input = sys.stdin.readline n = int(input()) arr = list(map(int, input().split())) dpMax = [0] * n dpArr = [[] for _ in range(n)] dpArr[0] = [arr[0]] maxIdx = 0 for i in range(1, n): for j in range(i - 1, -1, -1): if arr[i] > arr[j]: if dpMax[j] + 1 > dpMax[i]: dpMax[i] = dpMax[j] + 1 dpArr[i] = dp..
[Python/ํ์ด์ฌ] ๋ฐฑ์ค 2263๋ฒ: ํธ๋ฆฌ์ ์ํ
๋ฌธ์ ํ์ด ์ค์ ์ํ : 7 3 8 1 9 4 10 0 11 5 2 6 ํ์ ์ํ : 7 8 3 9 10 4 1 11 5 6 2 0 ํ์ ์ํ๋ ์ต์์ ๋ฃจํธ๋ฅผ ๋งจ ๋ง์ง๋ง์ ๋ฐฉ๋ฌธํ๋ฉฐ, ์ค์ ์ํ๋ ์ผ์ชฝ ์๋ธ ํธ๋ฆฌ, ๋ฃจํธ, ์ค๋ฅธ์ชฝ ์๋ธ ํธ๋ฆฌ ์์ผ๋ก ๋ฐฉ๋ฌธํ๋ค. ๋ฐ๋ผ์, ํ์ ์ํ์ ๋งจ ๋ง์ง๋ง ์์๋ ์ต์์ ๋ฃจํธ์ด๋ฉฐ ์ด๋ฅผ ๊ธฐ์ค์ผ๋ก ์ค์ ์ํ๋ฅผ ๋๋๋ฉด, ์ผ์ชฝ์ ์ผ์ชฝ ์๋ธ ํธ๋ฆฌ, ์ค๋ฅธ์ชฝ์ ์ค๋ฅธ์ชฝ ์๋ธ ํธ๋ฆฌ์์ ์ ์ ์๋ค. ์ค์ ์ํ : 7 3 8 1 9 4 10 0 11 5 2 6 ํ์ ์ํ : 7 8 3 9 10 4 1 11 5 6 2 0 ์ด๋ ์ค์ ์ํ์์ ์ผ์ชฝ ์๋ธ ํธ๋ฆฌ์ ๋ฒ์๋ ์์ ์ธ๋ฑ์ค ~ (์์ ์ธ๋ฑ์ค + ์ผ์ชฝ ์๋ธ ํธ๋ฆฌ์ ๋ ธ๋ ์ - 1) ์ค์ ์ํ์์ ์ค๋ฅธ์ชฝ ์๋ธ ํธ๋ฆฌ์ ๋ฒ์๋ (๋ ์ธ๋ฑ์ค - ์ค..
[Python/ํ์ด์ฌ] ๋ฐฑ์ค 9372๋ฒ: ์๊ทผ์ด์ ์ฌํ
๋ฌธ์ ํ์ด ๋ฌธ์ ์์ ์ฃผ์ด์ง ์ ๋ณด๋ฅผ ์ ํ์ฉํด์ผ ํ๋ค. ์ฃผ์ด์ง๋ ๋นํ ์ค์ผ์ค์ ํญ์ ์ฐ๊ฒฐ ๊ทธ๋ํ๋ฅผ ์ด๋ฃฌ๋ค. ๋ฐ๋ผ์ ์๋ฌด ๋ ธ๋๋ ์ ํํด๋ ๊ทธ ๋ ธ๋์์ ๋ชจ๋ ๋ ธ๋๋ก ๊ฐ ์ ์์์ ์๋ฏธํ๋ค. (์๋ ๊ทธ๋ฆผ ์ฐธ๊ณ ) ๋ํ ์ฐ๊ฒฐ ๊ทธ๋ํ๋ฅผ ์ ์งํ๊ธฐ ์ํ ๊ฐ์ ์ ์ต์ ๊ฐ์๋ (๋ ธ๋์ ์ - 1)์ด๋ค. ์ด๋ฅผ ์ ์ฅ ํธ๋ฆฌ๋ผ ํ๋ค. https://terms.naver.com/entry.naver?docId=837730&cid=42344&categoryId=42344 ์ ์ฅ ํธ๋ฆฌ ์ฐ๊ฒฐ ๊ทธ๋ํ์ ๋ถ๋ถ ๊ทธ๋ํ๋ก์ ๊ทธ ๊ทธ๋ํ์ ๋ชจ๋ ์ ์ ๊ณผ ๊ฐ์ ์ ๋ถ๋ถ ์งํฉ์ผ๋ก ๊ตฌ์ฑ๋๋ ํธ๋ฆฌ. ๋ชจ๋ ๋ ธ๋๋ ์ ์ด๋ ํ๋์ ๊ฐ์ ์ ์ฐ๊ฒฐ๋์ด ์์ด์ผ ํ๋ค. terms.naver.com ์ฆ, ๋นํ๊ธฐ์ ์ข ๋ฅ = ๊ฐ์ ์ ์ฌํ ๊ฐ ๋๋ผ์ ์ = ๋ ธ๋์ ์ ๊ฐ์ ์ ์ต์..
[Python/ํ์ด์ฌ] ๋ฐฑ์ค 5639๋ฒ: ์ด์ง ๊ฒ์ ํธ๋ฆฌ
๋ฌธ์ ํ์ด ์ ์ ์ํํ ๊ฒฐ๊ณผ 50 30 24 5 28 45 98 52 60 ์ฒซ ๋ฒ์งธ ์์๊ฐ ๋ฃจํธ ๋ ธ๋ (์ ์ ์ํ์ ์ฑ์ง์ ์ํด) ์ผ์ชฝ ์๋ธ ํธ๋ฆฌ = ๋ฃจํธ ๋ ธ๋๋ณด๋ค ์์ ์์์ธ ๊ฒฝ์ฐ ์ค๋ฅธ์ชฝ ์๋ธ ํธ๋ฆฌ = ๋ฃจํธ ๋ ธ๋๋ณด๋ค ํฐ ์์์ ๊ฒฝ์ฐ ์ ์ ์ํ๋ฅผ ํ์ผ๋ฏ๋ก ๋ฃจํธ ๋ ธ๋๋ณด๋ค ํฐ ์์๊ฐ ๋์ค๋ ์ง์ ์ด ์ผ์ชฝ ์๋ธ ํธ๋ฆฌ์ ์ค๋ฅธ์ชฝ ์๋ธ ํธ๋ฆฌ๋ฅผ ๋๋๋ ์ง์ ๊ณผ ๊ฐ๋ค. 50 30 24 5 28 45 98 52 60 ์ด๋ก = ๋ฃจํธ ๋ ธ๋, ๋นจ๊ฐ = ์ผ์ชฝ ์๋ธ ํธ๋ฆฌ, ํ๋ = ์ค๋ฅธ์ชฝ ์๋ธ ํธ๋ฆฌ ์ ๊ฒฐ๊ณผ๋ฅผ ํ์ฉํด ํ์ ์ํ๋ฅผ ํด์ฃผ๋ฉด ๋๋ค. ์ฝ๋ import sys sys.setrecursionlimit(10 ** 9) input = sys.stdin.readline pre = [] while True: try: pre.appen..
[Python/ํ์ด์ฌ] ๋ฐฑ์ค 1417๋ฒ: ๊ตญํ์์ ์ ๊ฑฐ
๋ฌธ์ ํ์ด ๊ธฐํธ 1๋ฒ์ ์ ์ธํ ๋๋จธ์ง ํ๋ฅผ ์ต๋ ํ์ ๋ฃ๋๋ค. ํ์ pop()ํ์ ๋ ๋์จ ํ๋ณด์ ํ๊ฐ ๊ธฐํธ 1๋ฒ์ ํ๋ณด๋ค ๋ง๋ค๋ฉด, ๊ทธ ํ๋ณด๋ฅผ ํ๋ช ๋งค์ํ๊ณ ๋ค์ ํ์ ๋ฃ๋๋ค. ์ ๊ณผ์ ์ ๊ธฐํธ 1๋ฒ์ ํ๊ฐ ์ ์ผ ๋ง์ ๋๊น์ง ๋ฐ๋ณตํ๋ค. ์ฝ๋ import sys, heapq input = sys.stdin.readline n = int(input()) win = int(input()) nums = [] for _ in range(n - 1): num = int(input()) heapq.heappush(nums, (-num, num)) cnt = 0 while nums: num = heapq.heappop(nums)[1] if num >= win: num -= 1 win += 1 cnt += 1 heapq...
[Python/ํ์ด์ฌ] ๋ฐฑ์ค 11779๋ฒ: ์ต์๋น์ฉ ๊ตฌํ๊ธฐ 2
๋ฌธ์ ํ์ด ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๋, ์ต๋จ๊ฒฝ๋ก ๊ฐ์ด ๊ฐฑ์ ๋ ๋ ๊ทธ๋์ ๋ ธ๋ ๊ฐ๋ ํจ๊ป ๊ธฐ๋กํ๋ค. ์์ ๋ ธ๋๊ฐ 1๋ฒ ์ผ ๋, 1. ์ด๊ธฐ๊ฐ distance : 1๋ฒ ๋ ธ๋์์ ๋ค๋ฅธ ๋ ธ๋๋ก ๊ฐ ์ ์๋ ์ต๋จ ๊ฒฝ๋ก 1 2 3 4 5 6 0 4 2 INF INF INF nearnest ๊ฐ : ๋ฐฉ๋ฌธํ ๋ ธ๋({1}) ์ค์์ ๊ฐ์ฅ ๊ฐ๊น์ด ๋ ธ๋ 1 2 3 4 5 6 1 1 1 1 1 1 2. ๊ฐฑ์ distance : 1๋ฒ ๋ ธ๋์์ n๋ฒ ๋ ธ๋๋ก ๊ฐ๋ ๋น์ฉ๋ณด๋ค 1~3, 3~n์ผ๋ก ๊ฐ๋ ๋น์ฉ์ด ๋ ์์ผ๋ฉด ๊ฐฑ์ 1 2 3 4 5 6 0 4 2 INF 6 (๊ฐฑ์ ) INF nearnest ๊ฐ : ๋ฐฉ๋ฌธํ ๋ ธ๋({1, 3}) ์ค์์ ๊ฐ์ฅ ๊ฐ๊น์ด ๋ ธ๋ 1 2 3 4 5 6 1 1 1 1 3 (๊ฐฑ์ ) 1 3. 2๋ฒ ๋ฐ๋ณต ๋ฌธ์ ์์ ์ฃผ์ด..