| ์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
|---|---|---|---|---|---|---|
| 1 | 2 | 3 | 4 | 5 | 6 | |
| 7 | 8 | 9 | 10 | 11 | 12 | 13 |
| 14 | 15 | 16 | 17 | 18 | 19 | 20 |
| 21 | 22 | 23 | 24 | 25 | 26 | 27 |
| 28 | 29 | 30 | 31 |
- ๋ฏธ๊ตญ์ฃผ์
- Kotlin
- pnpm
- ์๋ฐ
- Swift
- ์๋ฐ ์๊ณ ๋ฆฌ์ฆ
- ๋ฏธ๊ตญ๋ฐฐ๋น์ฃผํฌ์
- kotlin algorithm
- ์ฝํ๋ฆฐ ์คํ
- ๋ฐฑ์ค ์ฝํ๋ฆฐ
- ์๊ณ ๋ฆฌ์ฆ
- linux
- ์ฝํ๋ฆฐ ์๊ณ ๋ฆฌ์ฆ
- java ์ฝ๋ฉ ํ ์คํธ
- ๋ฐฑ์ค
- ์ฝํ๋ฆฐ
- javascript
- ํ์ด์ฌ
- ํ์ฝํ
- ํ๋ก๊ทธ๋๋จธ์ค
- ๋ฐฐ๋น์ฃผ
- js
- kotlin ์๊ณ ๋ฆฌ์ฆ
- ์๋ฐ์คํฌ๋ฆฝํธ
- vue3
- Java
- python
- GIT
- CI/CD
- Vue.js
- Today
- Total
๋ชฉ๋กpython (5)
๐ ์ ์ด์ ๋จธ๋ฆฟ์์ผ๋ก
์ ๋์จ ํ์ธ๋ ํ์ด์ฌ ๊ตฌํํ๊ธฐ / union - find by Phython ์ ๋์จ / ํ์ธ๋๋ ํ์ฌ ๋ ธ๋๋ค์ด ๊ฐ์ ๊ทธ๋ฃน์ ์ํด ์๋์ง ํ์ธํ๊ณ ๊ฐ์ ๊ทธ๋ฃน์ผ๋ก ๋ง๋๋ ๋ณํฉ์ด ํ์ํ ๋ ์ฌ์ฉํ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค. find ์๊ณ ๋ฆฌ์ฆ ๊ตฌํ par = [ -1 for i in range(N + 1) ] # ๋ฃจํธ๋ฅผ ๋ด์ ๋ฐฐ์ด def find(x): # ๋ฃจํธ๋ฅผ ์ฐพ์์ฃผ๋ ํจ์ if par[x] ์์ง ์ฐ๊ฒฐ๋ ์ ์ด ์์ par[x] = find(par[x]) # ์์ ์ ๋ถ๋ชจ๋ฅผ ๋ถ๋ชจ->๋ถ๋ชจ ๋ฅผ ์ฌ๊ท๋ก ๋ฃจํธ ๋ถ๋ชจ๋ฅผ ์ฐพ์ return par[x] # ๋ฃจํธ ๋ถ๋ชจ๋ฅผ ๋ฆฌํด par ์ด๋ผ๋ ๋ฐฐ์ด์๋ ๊ฐ ๋ ธ๋์ ๋ถ๋ชจ๋ฅผ ๋ด์ ๋์ต๋๋ค. par ๋ฐฐ์ด์ index๋ ๊ฐ..
์์ด์ด๋, N๊ฐ์ ์์์์ ์ํ๋ ๊ฐ์๋ฅผ ๋ฝ์ ๋, ์์๊น์ง ๊ณ ๋ คํ๋ ๊ฒ์ ๋งํฉ๋๋ค. ์์) [1, 2, 3] ๋ฐฐ์ด์์ 2๊ฐ์ ์์๋ฅผ ์ ํํ ๊ฒฝ์ฐ => (1, 2), (1, 3), (2, 3), (2, 1), (2, 3), (3, 1), (3, 2) ์์ ๊ฐ์ ๊ฒฐ๊ณผ์ฒ๋ผ (1, 2), (2, 1)์ ๊ฒฝ์ฐ๋ ์๋ก ๋ค๋ฅธ ๊ฒ์ผ๋ก ํ๋จํฉ๋๋ค. ๐ฅธ ์ฌ๊ท๋ฅผ ํตํ ์ฝ๋ ๊ตฌํ test = [1, 2, 3] test_len = len(test) N = 2 # ๋ฝ์ ์์ด์ ๊ฐ์ visit = [0] * test_len # ํด๋น index์ ๊ฐ์ ์ฌ์ฉํ๋์ง ์ฌ๋ถ arr = [0] * N # ํ์ฌ ์์ด์ ๋ด์ ๋ฐฐ์ด arr_list = [] # ๋ชจ๋ ์์ด์ ๋ด์ ๋ฐฐ์ด def permutaion(level): if level >=..
๐ฉ ํ๋ก์ด๋ ์์ฌ ์๊ณ ๋ฆฌ์ฆ ํ์ด์ฌ ๊ตฌํ ํ๋ก์ด๋ ์์ฌ์ ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ๊ณผ ๊ฐ์ด ์ต๋จ๊ฑฐ๋ฆฌ ํน์ ์ต์๋น์ฉ์ ๊ตฌํ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค. ํ๋ก์ด๋ ์์ฌ์ ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ๊ณผ๋ ๋ฌ๋ฆฌ ๋ชจ๋ ๋ ธ๋์์ ๋ค๋ฅธ ๋ชจ๋ ๋ ธ๋๋ค๊น์ง์ ์ต์ ๊ฑฐ๋ฆฌ(ํน์ ์ต์๋น์ฉ)์ ๊ตฌํ๊ธฐ ๋๋ฌธ์ "์ด๋๊ฐ๋ฅผ ๊ฒฝ์ ํ๋ค."๋ผ๋ ์กฐ๊ฑด์ด ์ฃผ์ด์ง ๋, ์ฌ์ฉ์ ๊ณ ๋ คํ๊ธฐ ์ข์ ์๊ณ ๋ฆฌ์ฆ ์ ๋๋ค. ๋ค๋ง, ์ถ๋ฐ์ (s), ๋์ฐฉ์ง์ (e), ๊ฒฝ์ ์ง(p)์ ๋ชจ๋ ๋ ธ๋๋ฅผ ๊ณ ๋ คํด์ผํ๋ฏ๋ก ์๊ฐ ๋ณต์ก๋๋ O(N^3)์ผ๋ก ํฐ ํธ ์ ๋๋ค. ์ฆ, ๋ฌธ์ ์์ ์ฃผ์ด์ง ๋ ธ๋(N)์ ์ต๋๊ฐ์ ๊ณ ๋ คํด ๋ฏธ๋ฆฌ ๊ณ์ฐํด ์ฌ์ฉํ ๊ฐ์น๊ฐ ์๋ ์๊ณ ๋ฆฌ์ฆ์ธ์ง ๊ณ ๋ คํด๋ด์ผํฉ๋๋ค. โ๏ธ ํ๋ก์ด๋ ์์ฌ ์๊ณ ๋ฆฌ์ฆ ์ ๊ทธ๋ฆผ์ ๊ฒฝ์ฐ๋ ์ถ๋ฐ์ง์ ์ด 1๋ฒ ๋ ธ๋, ๋์ฐฉ์ง์ ์ด 4๋ฒ ๋ ธ๋์ธ ๊ฒฝ์ฐ ์ ๋๋ค. 1 -> 4๋ก ๊ฐ๋๊ฒ ๊ฒฝ์ ..
GCD(Greatest Common Divisor) ์ต๋ ๊ณต์ฝ์ ๊ตฌํ๊ธฐ ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ ์ฌ์ฉ def gcd(a, b): while b: a, b = b, a % b return a a = b x q + r ์ด๋ผ๊ณ ํ์ ๋, GCD(a, b) = GCD(b, r)๋ฅผ ๋ง์กฑํ๋ค. ๊ฐ๋จ ์ฆ๋ช : ์ํ์ ์ผ๋ก ์ฆ๋ช ํ๋ ๋ฐฉ๋ฒ์ด ์์ง๋ง ์ดํด๋ฅผ ์ํด์ ๊ฐ๋จํ ์ค๋ช ํ์๋ฉด ์๋์ ๊ฐ์ด ํํํ ์ ์๋ค. b = r x m + n์ผ๋ก ํํํ ๋, n์ด 0์ด๋ผ๋ฉด b = rm์ผ๋ก ํํ๋๋ค. ์ฆ, b์ r์ ์ต๋ ๊ณต์ฝ์ GCD(b, r) = m์ด ๋๋ค. a = bq + r = rmq + r = r(mq + 1) ์ด๋ฏ๋ก GCD(a, b) = r ์ด๋ค. => GCD(a, b) = GCD(b, r) = GCD(r, 0) = r LCM(Lo..
ํ๋ก๊ทธ๋๋ฐ์ ์ฒ์ ํฅ๋ฏธ๋ฅผ ๋๊ปด๋ณธ ๊ฒ์ด ํ๋ถ์์ ์๋ํ ํ๋ก๊ทธ๋จ์ ๊ฒฝํํ ํ์๋ค. ํ์ด์ฌ ์์ฒด๊ฐ ํธ๋ฆฌํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ก ๋น ๋ฅด๊ณ ๊ฐ๋จํ ์๋ํ ํ๋ก๊ทธ๋จ์ ๋ง๋ค๊ธฐ์ ์ฐธ ์ข์ ๊ฒ ๊ฐ๋ค. ์ฝ๊ฐ์ ๊ณ๊ธฐ๊ฐ ์๊ฒจ์ ๊ฐ๋จํ๋ฉด์ ์ฌ๋ฐ๋ ํ๋ก๊ทธ๋จ์ ๋ง๋ค๊ณ ์ถ์ด์ "์ฌํ๊ทผ๋ฌด ๋์ฐ๋ฏธ"๋ผ๋ ํ๋ก๊ทธ๋จ์ ๋ง๋ค์ด๋ดค๋ค. โถ ๋ฌด์จ ํ๋ก๊ทธ๋จ์ผ๊น? ์ฌ์ค ๊ฑฐ์ฐฝํ ์ด๋ฆ์ ๋นํด์ ์๋นํ ํ์ ..ใ ? ๊ฐ๋จํ ํ๋ก๊ทธ๋จ์ด๋ค. ํน๋ณํ ๊ธฐ๋ฅ์ ์๊ณ ํ๋ก๊ทธ๋จ์ ์คํํ๋ฉด ๋ง์ฐ์ค๋ฅผ ์๋์ผ๋ก ์์ง์ฌ์ ํ๋ฉด ๊บผ์ง์ ๋ฐฉ์งํด์ค๋ค. โถ ์ ๋ง๋ค์์๊น? ๋ณ๋ก ์ธ๋ชจ์์ด ๋ณด์ด๋ ์ด ํ๋ก๊ทธ๋จ์ ๋ง๋ ๊ณ๊ธฐ๊ฐ ์๋๋ฐ ์ฝ๋ก๋๋ก ์ธํด์ ์น๋๋๊ฐ ์ฌํ๊ทผ๋ฌด๋ฅผ ํ๋ ์๊ฐ์ด ์๋์ ์ผ๋ก ๋ง์์ก๋ค. ์ฌ๋ด์ ์๊ฒฉ ํ๋ก๊ทธ๋จ์ ์ด์ฉํ๋๋ฐ ์ด ํ๋ก๊ทธ๋จ์ด ์ผ์ ์๊ฐ ๋์ ์ฌ์ฉ์ ์ ๋ ฅ(ํค๋ณด๋, ๋ง์ฐ์ค ์ฌ์ฉ)..
