notes
APS
์์ฝ๋ฉ์ ์ง์ํ๊ฒ ์๋ฒฝํ ํด๋ด๊ณ ์ ์ฝ๋ฉํ์..
์กฐ๊ฑด๋ฌธ์ ๊ผญ else: ๋ ๊ณ ๋ คํ์. if ๋ฌธ ์ผ๋๋ง ๊ณ ๋ คํ๋ ํ๋ฆ์ด computitational thinking ์ ๋ง์ง๋ง, ๋์น ์ ์๋ค.
ํด์ฌ ๋ค์ด๋๋ฏน ์์ else: ๋ฅผ ์ ํด๋ ๋๋ค๊ณ ์ฐฉ๊ฐํจ
์ฐ์ ์ผ๋ก ์ํํด์ผํ๋ ๊ฒ์ ๊ทธ๋ ค์ ํ์ ํ์ฌ ๊ตฌํํ์. ๋ฌธ์ ์์๊ฐ ์๋๋ผ
๊ณตํต๋๋ ์กฐ๊ฑด์ ํ์ ํ์.
๊ทธ๋ ค๋์ผ๋ฉด ๋ญ๋ถํฐ ์ง์๊ฐ์ผ ์ฐ์ ์ํ์ ์๊ธฐ ์ฝ๋ค
์ฝํ ์์ ๋ฌธ์ ํด์์ ๋ง์ ์๊ฐ์ด ๋ค์ด์, ๊ทธ๋ฅ ๋์ฌ ์ ์๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๋๋ ๊ฐ๊ฐ ํธ๋๊ฒ ๋์ ๊ฒ ๊ฐ๋ค. ๋ชจ๋ ๊ฐ๋ฅ์ฑ์ ์ํํ๋ฉฐ ํ๋ฒ์ ํํํ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ฃผ์ด์ง ์๊ฐ๋ด์ ํ๋๊ฒ ์ด๋ ต๋ค
ในใ .. ๋ฌธ์ฅ์ ์ ๋ต ์กฐ๊ฑด์ด ์๋ค..
๊ตฌํ์ ์ข ์ด์
aps ๋ฅผ ํ ๋ ์๊ฐํ ์๋ฃ๊ตฌ์กฐ๊ฐ ๊ตฌํํ ๋ ๋ค๋ฅธ ์๋ฃ๊ตฌ์กฐ๊ฐ ํธํ ์ ์๋ค. aps ํ๋ฉด์ ๊ตฌํ๊ฐ๋ฅ์ฑ๋ ๋์์ ๊น์ด ์๊ฐํ์.
๋ณ์์ค์ ์ ํ๊ณ , ๋ฌธ์ ๋ฅผ ํ๋ฌธ์ฅ ํ๋ฌธ์ฅ ์ฝ์ด๊ฐ๋ฉด์ ๋ณ์๋ฅผ ๋น๊ตํ์.
Ex) ๋ฑ ๋ฌธ์ ์์ ๋ฌธ์ ์ ์ฌ๊ณผ๊ฐ ์์ด์ง๋ค๊ณ ๋ช ์ํด์๋ ๊ฒ์ ๋ณด๊ณ , ์ฝ๋์์ ์ฌ๊ณผ๋ฅผ remove ํด์ค์ผ ํ๋ค๋ ๊ฒ์ ์ ์ ์๋ค.
๋ฌธ์ ๊ฐ ๋ง์ด ๋ณต์กํ ์
while True: ์ํ๋ ์ง์ ๋๋ฌ์ ์ํ exit()
๋ณ์์ค์ ์ ์ ๊ทน์ ์ผ๋ก ํ์ฉํ์. ๊ณผ๋ํ ์ธ๋ฑ์ฑ ใดใด
๋ด๊ฐ ํ์์ ์ผ๋ก ์ํํด์ผํ ๊ฒ๋ง ๊ตฌํํ์. ๊ณ์ฐ์ ์ปดํจํฐ๊ฐ
๊ตฌํ์ ํด๋๊ฐ๋ฉด์ ์ค๊ฐ ๋๋ฒ๊น ์ ํ์
์ต๋๊ฐ, ์ต์๊ฐ ์ ๋ฐ์ดํธ ์
min_answer = int(1e9) max_answer = -int(1e9)
์๋ฃ๊ตฌ์กฐ๊ฐ str ์ผ ๋ ๋ ํธํ ์ ์๋ค.
string[0] ์ " ์ด๋ค.
DP
์ DP ํ ๋ DP ํ ์ด๋ธ์ ์ด๋ป๊ฒ ๊ตฌ์ฑํ๋์ง๊ฐ ์ข ๋ ์ค์ํจ. ์ด๋ค์์ผ๋ก ํ ์ด๋ธ์ ๊ตฌ์ฑํ๋๋์ ๋ฐ๋ผ ๋ฌธ์ ์์ ์ฃผ์ด์ง ์ํฉ์ ์ฝ๊ฒ ๊ตฌํํ ์ ์์.
For loop
In list ๋ฅผ ์ ํ์ฉํ์ => range over ๊ฐ ์ผ์ด๋์ง ์๋๋ค.
for value in list:
๋ฐ๋ณต๋ฌธ range ๋ฅผ ํ์ฉํ์
for i in range(a,b,c): # a ๋ถํฐ ์์๋๋ฉฐ # b ์ ๊น์ง ํด๋น๋๊ณ # c ๋จ์๋ก ๋์ด๋๋ค
split ๋ ์ ๋ณด๋ค์ ์ ๋ ฅ๋ฐ๋ ๋์์ ์๋ฃ๋ฅผ ๋ง๋ค์
graph = [[] for _ in range(n+1)] for i in range(m): a,b = map(int,input().split()) graph[a].append(b)
for ๋ฌธ์์ List ๋ฅผ ํธ์งํ ๋ ์ฃผ์ !
for v in list: list.append(v + n) # ์์ฒ๋ผ ํ๊ฒ ๋๋ฉด ๋ฐ๋ณต๋ฌธ์์์ list ๊ฐ ํธ์ง๋๊ธฐ ๋๋ฌธ์ ์ค๋ฅ๊ฐ ์๊ธด๋ค length = len(list) for i in range(length): list.append(list[i] + n) # ๋ฒ๊ฑฐ๋กญ๋๋ผ๋ ์ด๋ฐ์์ผ๋ก ๊ตฌํํ์
for ๋ฌธ ์์์ ์ฌ์ฉํ ๋ณ์๋ ํด๋น for ๋ฌธ ์์์ ์ด๊ธฐํ
List - Based
Duque ์ rotate ์ต์ ์ ์๊ณ, ๋ฐ์๊ณ ํ์ ์ด ๊ฐ๋ฅํจ;;
์๋ฎฌ๋ ์ด์ ์ ํ ๋, 2์ฐจ์ ๋ฐฐ์ด์์ ์์น๊ฐ ๊ณ์ ๋ณํ๋ค๋ฉด, [x, y] ํํ์ element ๋ฅผ ๊ฐ๋ 1์ฐจ์ ๋ฆฌ์คํธ๋ก ๋ง๋ค์.
=> 2์ฐจ์ ๋ฐฐ์ด์์ ์ ๋ณด๊ฐ ๊ฒน์น๊ฑฐ๋ ์ธ๋ฑ์ค ๋ฒ์ ์ค๋ฅ๋ฅผ ๋ง์ ์ ์๋ค.
el_locs = [[x, y], [x, y], [x, y]...]
# ํด๋น ์์น๊ฐ v_locs ์์ ์๋์ง ์๋์ง if [x, y] in el_locs:
Queue ๋ Stack ์ ์ธ์ ๋ ธ๋๋ฅผ push ํ ๋ ๋ ธ๋ ์์ฒด์ ์ ๋ณด๋ฅผ ๋ด์ ๊ธฐ์กด ๋ ธ๋ ๊ธฐ๋ฐ์ผ๋ก ์ ๋ณด๋ฅผ ๋ถ์ฌํ์ฌ ์ธ์ ๋ ธ๋๋ฅผ push ํด์ค ์ ์๋ค.
# ex) data = [] for y in range(n): for x in range(n): if arr[y][x]: data.append((arr[y][x],0,y,x)) # ๊ทธ ์ด์ ๋ ธ๋๋ก ์ธํด ์งํ๋ ์ธ์ ๋ ธ๋๋ฅผ ํ์ ์ฝ์ ํ ๋ ๊ธฐ์กด ๋ ธ๋์ ์๊ฐ +1 ์ ํด์ฃผ๋ ๊ฐ๋ while q: virus,time, y,x = q.popleft() if time == s: break for i in range(4): ny = y + dy[i] nx = x + dx[i] if 0 <= ny < n and 0 <= nx < n: if not arr[ny][nx]: arr[ny][nx] = virus q.append((virus, time+1, ny,nx))
Permutation / Combination
from itertools import permutations from itertools import combinations a = [] b = [] items= [1,2,3,4] list(combinations(items, m)) list(permutations(items, m))
Least common multiple
Arr = list(map(int,list(input().split()))) n = 1 while n%Arr[0] or n%Arr[1] or n%Arr[2]: n += 1 print(n)
2 - dimensional array
2์ฐจ์ ๋ฐฐ์ด์ ์์ ํด์ผํ ๋๋ ๊ธฐ์กด์ ๋ฐฐ์ด์ ์์ ํ์ง ๋ง๊ณ , ๊ฐ์ ํฌ๊ธฐ์ ๋น ๋ฐฐ์ด์ ๋ง๋ค์ด ๋ชจ๋ ์ธ๋ฑ์ค์ ์ ์ ํ ๊ฐ์ ํ ๋นํ ํ ๊ต์ฒดํ๋ ๋ฐฉ์์ ๋ฐ๋ฅด์
90 ๋ ํ์
list(zip(*arr[::-1]))
split ๋ ์ ๋ณด๋ฅผ ์ ๋ ฅ๋ฐ์ ๋
graph = [[] for _ in range(n+1)] for i in range(m): a,b = map(int,input().split()) graph[a].append(b)
๊ธฐ๋ณธ์ ์ผ๋ก nx, ny ์ ์กฐ๊ฑด๋ฌธ์ ํ ๋๋ ์ธ๋ฑ์ค ๋ฒ์ ๋จผ์ ๊ฒํ ํด์ผํ๋ค.
if 0 > nx or r <= nx or 0 > ny or c <= ny or a[nx][ny] == 1: d = (d + 1) % 4 nx = x + dx[d] ny = y + dy[d] ๋ง์ฝ ์กฐ๊ฑด๋ฌธ์์ a[nx][ny] ๋ฅผ ๋จผ์ ์ํํ๋ค๋ฉด ์ธ๋ฑ์ค ์ค๋ฅ๊ฐ ๋์ง๋ง, ์์์ ๋ฒ์๊ฐ ๋ฒ์ด๋ ๊ฒ์ด ํ๋๋ผ๋ ๋ฐ๊ฒฌ๋๋ฉด or ๋ฌธ์ด๊ธฐ๋๋ฌธ์ ๊ทธ๋ฅ ๋์ด๊ฐ ์ ์๋ค.
ํ์
list(zip(*arr[::-1]))
Recursion
ํจ์๋ด์์ ํ์ํ ๋ณ์๋ฅผ ์๊ฐํ๊ณ ์ธ์ ์ค์ ์ ํ์
Hash
๋์ ๋๋ฆฌ ๊ตฌํ
# key ๋ฅผ ์ซ์ ์์๋๋ก ํ ๋ dic = dict() lst = [chr(i) for i in range(ord('A'), ord('Z') + 1)] # Value ๋ก ๊ฐ์ง ๊ฐ๋ค์ ๋ฆฌ์คํธ ๊ตฌํ for idx, char in enumerate(lst): dic[char] = idx + 1 # ์ฌ๊ธฐ์ ์์ ๋ฐ๊ฟ์ฃผ๋ฉด ํค์ ๋ฐธ๋ฅ๊ฐ ๋ฐ๋๋ค
Last updated
Was this helpful?