Network/Maximum Flow ์ ๋๊ทธ๋ํ : ๊ฐ์ ์ weight๊ฐ ์ ์ ์์ ์ ์ ์ผ๋ก ๋ณด๋ผ์์๋ ์ต๋์ ๋์ ์๋ฏธํ๋ ๊ทธ๋ํ ์ต๋์ ๋ : ํด๋น ๊ฐ์ ์ ํตํด ๋์์ ํ๋ ค๋ณด๋ผ์์๋ ๋ฌผ์ ์ต๋์น ์ด๋ฌํ ์ ๋๊ทธ๋ํ์์, Source์ ์ ์์ Sink์ ์ ๊น์ง ์ต๋ ์ผ๋ง๋งํผ์ ์ ๋์ด ์ง๋๊ฐ์์๋์ง์ ๊ดํ ๋ฌธ์ ๋ฅผ Network/Maximum Flow๋ผ๊ณ ํ๋ค. ์๋์ ๊ฐ์ด, ์๋ก(๊ฐ์ )์ 1์ด๋ง๋ค ์ง๋ ์์๋ ๋ฌผ์ ์ต๋์น๊ฐ ์ ์๋์ด์๋ค๋ฉด, ์๋ก๋ ์์ ์ ์ฉ๋์ด์์ ๋ฌผ์ ํต๊ณผ ์ํฌ์์๋ค. ๋ฐ๋ผ์ ๊ฒฐ๊ณผ์ ์ผ๋ก ํต๊ณผํ ์์๋ ๋ฌผ์ ์ต๋๋์ ์ผ์ชฝ์ 2, ์ค๋ฅธ์ชฝ์ 4์ด๋ค. ๋ฐ๋ผ์ ์์ ๊ทธ๋ํ๋ฅผ Maximum Flow(์ต๋์ ๋)์ผ๋ก ๋ณด๋ด๋ฉด ๊ทธ ๊ฐ์ 7์ด๋ค. ์ข์ธก๊ฐ์ ์ค์ ๋ก ํด๋น ๊ฐ์ ์ ํ๋ฅธ ์ ๋(flow), ์ฐ์ธก๊ฐ์ ํด๋น ๊ฐ์ ์ ..
Plane Sweeping ์ง๊ฐ๋ํ์ ๋์ด๋ฅผ ๊ตฌํ ๋ ์ฐ์ด๋ ์๊ณ ๋ฆฌ์ฆ ๊ณ์น ๋ถ๋ถ์ด ์๊ธฐ๋๋ฌธ์ ๋จ์ํ ๊ณต์์ ๋์ด๋ฅผ ๊ตฌํ๊ธฐ ์ฝ์ง ์๋ค. ๊ฐ ์ง์ฌ๊ฐํ์ 4๊ฐ์ ๊ผญ์ง์ ์ ๊ฐ์ง๋ค. ๋ฐ๋ผ์ n๊ฐ์ ์ง์ฌ๊ฐํ์ด๋ผ๋ฉด, ์ต๋ 2n๊ฐ์ x์ขํ์ 2n๊ฐ์ y์ขํ๊ฐ ์ฌ์ฉ๋๋ค. ์ด๋ ๊ฒ ๊ฐ ๊ผญ์ง์ ์ผ๋ก ๋๋๋ฉด, ๊ฐ ์์ญ์ ๋์ด๋ฅผ ๊ตฌํ๋ค ๊ทธ ํฉ์ผ๋ก ์ ๋ต์ ๊ตฌํ ์์๋ค. ๋จผ์ ์ฌ์ฉ๋๋ x,y์ขํ๋ฅผ ๋ชจ๋ ๊ตฌํ๋ค ์ ๋ ฌ์ํจ๋ค. (์์๋ค์ด ๊ผญ ์ ์ผํ ํ์๋ ์๋ค) ์ดํ x,y์ขํ๋ก ์๋ ค์ง ์์ญ๋ค์ ์ํํ๋ฉฐ, ์ฌ๊ฐํ์ด ํฌํจ๋์์ผ๋ฉด ๋์ด๋ฅผ ๋ํด์ค๋ค. ์ด๋, ์์๋ค์ด ์ ์ผํ์ง์๋ค๋ฉด ์ ๋ ฌ๋ ๋ ๊ฐ์๊ฐ์ด ๋ถ์ด์์ผ๋ฏ๋ก ๊ทธ ์์ญ์ ๋์ด๊ฐ 0์ด ๋์ด ๋ฌด์ํด๋ ๋๊ฒ ๋๋ค. ์ด ๊ณผ์ ์์ Segment Tree๋ฅผ ์ฌ์ฉํด ๊ตฌ๊ฐ๊ฐฑ์ ์๋๋ฅผ ์ค์ฌ ์๊ฐ๋ณต์ก๋๋ฅผ ์ค์ผ์์๋ค. ..
KMP (Knuth–Morris–Pratt, ๋ฌธ์์ด ํ์ ์๊ณ ๋ฆฌ์ฆ) ๊ธฐ๋ณธ์ ์ธ ๋ฌธ์์ด ์์ ํ์ ์๊ณ ๋ฆฌ์ฆ์ ๋นํด, ์ฝ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ๊ณต๊ฐ์ ์ด์ฉํด ๋ถํ์ํ ๋น๊ตํ์๋ฅผ ์ค์ฌ ์๊ฐ๋ณต์ก๋๋ฅผ ์ค์ธ๋ค. ์๋ฅผ ๋ค์ด, samsamsung ๋ฌธ์์ด์์ samsamsong ๋ฌธ์์ด์ ์ฐพ๋๋ค๋ฉด ์๋๋ 0๋ฒ์งธ ์ธ๋ฑ์ค s๋ถํฐ ์์ํ์ฌ ์ญ ๊ฐ์์ง ๋น๊ตํ๋ค๊ฐ u๊ฐ ๋ค๋ฅด๋ฏ๋ก ์คํจํ๊ณ ์ดํ 1๋ฒ์งธ ์ธ๋ฑ์ค a๋ถํฐ ๋ค์ ๋น๊ตํ๊ธฐ ์์ํด, ์ด๋ ์ฒ์๋ถํฐ ๋ค๋ฅด๋ฏ๋ก ๋ฐ๋ก ์คํจ, ์ดํ 2๋ฒ์งธ ์ธ๋ฑ์ค m๋ถํฐ ~... ๋ฐฉ์์ผ๋ก ๋น๊ตํ๋ค. => ์ด๋ KMP๋ฅผ ์ฌ์ฉํ๋ฉด, ๋งจ์ฒ์ u๊ฐ ๋ฌ๋ผ์ ์คํจํ ์ํ์์ samsamsung์ sams์ samsamsong์ sams๊ฐ ๊ฐ๋ค๋ ์ ๋ณด๋ฅผ ๊ธฐ์ตํ๊ณ ์๋ค. (๋ฌผ๋ก ๊ฒฐ๊ณผ์ ์ผ๋ก ๋น๊ต๊ฐ ์คํจํ๊ฒ ๋๊ฒ ์ง๋ง) ์์ ์ ๋ณด๋ฅผ ์ด์ฉํด..
Permutation, Combination (์์ด, ์กฐํฉ) ํ๋ฅ , ๊ฒฝ์ฐ์์, ๊ณฑ์๋ฒ์น Permutation ์์ด : ์๋ก๋ค๋ฅธ n๊ฐ์ ์์๋ค์ค r๊ฐ๋ฅผ ์ค๋ณต์์ด ์ ํํ์ฌ ์์์๊ฒ ๋ฐฐ์ดํ๋ ๊ฒฝ์ฐ nPr = n * (n-1) * ... * (n-r+1) = n! / (n-r)! Combination ์กฐํฉ : ์๋ก๋ค๋ฅธ n๊ฐ์ ์์๋ค์ค r๊ฐ๋ฅผ ์ค๋ณต์์ด ์ ํํ๋ ๊ฒฝ์ฐ. (์์์์) nCr = nPr / r! = n! / r!(n-r)! ์ฑ์ง1 : nCr = nCn-r ์ฑ์ง2 : nCr = n-1Cr-1 + n-1Cr from ํ์ค์นผ์ ์ผ๊ฐํ ํ์ค์นผ์ ์ผ๊ฐํ (n, r = 0๋ถํฐ ์์) => ์ด๋ฅผ ์ด์ฉํด ๋์ ๊ณํ๋ฒ์ผ๋ก ํ๊ธฐ๋ ํ๋ค. Debugging) DP_bottom up & ํ์ค์นผ์ ์ผ๊ฐํ ์ด์ฉ ํฐ์์์์ 100..
โป ๊ท์ฐฎ์๋ ์ง์ ์์ผ๋ก ์ฐ๊ณ ๊ทธ๋ฆฌ๋ฉฐ ์๊ฐํด์ผ ์ดํด๊ฐ ๋น ๋ฅด๋ค Example 1 : Knapsack (๋ฐฐ๋ญ ๋ฌธ์ ) Dynamic Programming ๋ฌด๊ฒ์ ๊ฐ์น๊ฐ ์ ํด์ง N๊ฐ์ ๋ฌผ๊ฑด์ด ์์๋, ๊ฐ์น์ ์ดํฉ์ด max๊ฐ ๋๋๋ก ๋ฐฐ๋ญ์ ์ธ๋ ๋ฌธ์ . ์ด๋, ๋ฐฐ๋ญ์ ๋ฌด๊ฒ ์ ํ์ K์ด๋ค. (๊ฐ ๋ฌผ๊ฑด์ 1๊ฐ์ฉ๋ง ์กด์ฌํ๋ฉฐ, ๋ฐฐ๋ญ์ ๋ฃ๊ฑฐ๋/์๋ฃ๊ฑฐ๋) ๋์ ๊ตํ๋ฌธ์ ์ ๋ง์ฐฌ๊ฐ์ง๋ก Greedyํ ๋ฐฉ๋ฒ์ผ๋ก ํด๊ฒฐ๋์ง์์. ex) V[N] = {13,8,6,12} W[N] = {6,4,3,5} D[i][j] = i๋ฒ์งธ ๋ฌผ๊ฑด๊น์ง ๋ฃ์์ง/์๋ฃ์์ง ์ ํ์๋, ๋ฌด๊ฒ j์ดํ๋ฅผ ์ฑ์ฐ๋ ๊ฐ์น์ ํฉ์ค ์ต๋๊ฐ => ์ ํ์ : D[i][j] = Max(D[i-1][j], D[i-1][j-W[i]]+V[i]) Max์์ ๋น๊ตํ๋ ๋ ๊ฐ์ค, ์ ์๋ ์ด์ ..
Dynamic Programming (๋์ ๊ณํ๋ฒ) ๋ณต์กํ ๋ฌธ์ ๋ฅผ ์ฌ๋ฌ๊ฐ์ ์์๋ถ๋ถ๋ฌธ์ (sub-problem)์ผ๋ก ๋๋์ด ํด๊ฒฐํ๋ ๊ธฐ๋ฒ. ์ด๋ฏธ ๊ณ์ฐ๋ ๋ถ๋ถ ๋ฌธ์ ๊ฐ ๋ค์ ๋ฐ์ํ๋ฉด, ์๋กญ๊ฒ ๊ณ์ฐํ์ง์๊ณ ์ด์ ์ ๊ณ์ฐ๊ฐ์ ์ฐธ์กฐํด ์ด์ฉํ ์ ์๋ค. DP๋ฅผ ํตํด ๋ถ๋ถ๋ฌธ์ ๋ฅผ ๋ค์ ํด๊ฒฐํ๋ ์๊ฐ์ ์ ์ฝํ ์ ์์ง๋ง, ์ด์ ๊ณ์ฐ๊ฐ์ ์ ์ฅํ ๊ณต๊ฐ์ด ํ์ํ๋ฏ๋ก Time - Space๊ฐ์ trade off๋ผ๊ณ ํ ์ ์๋ค. ex. ํผ๋ณด๋์น ๋จ์ํ์์ผ๋ก ๊ตฌํ์, ์์ ๊ฐ์ด ์ฌ๋ฌ๋ฒ ๊ณ์ฐ๋๋ค. => Memorization : ํ๋ฒ ๊ณ์ฐ๋ ๊ฐ์ ๊ธฐ๋กํด๋๊ณ ์ดํ ์ค๋ณตํธ์ถ ๋์์๋ ์๋กญ๊ฒ ๊ณ์ฐํ๋๊ฒ ์๋ ์ ์ฅํด๋๊ฐ์ ๊ฐ์ ธ์ ์ฌ์ฉํ๋ค. fibonacci_topdown Top-Down / Bottom-Up Top-down ๋ฐฉ์์ ํฐ ๋ฌธ์ ์์..
Disjoint-set Algorithm (์๋ก์ ์งํฉ ์๊ณ ๋ฆฌ์ฆ) ์งํฉ, ๊ทธ๋ฃน์ ๊ด๋ฆฌํ๋ ์๊ณ ๋ฆฌ์ฆ ๊ฐ ๊ทธ๋ฃน์ ํธ๋ฆฌ๊ตฌ์กฐ๋ก ๊ด๋ฆฌ ํฌ๊ฒ 2๊ฐ์ง์ ์ฐ์ฐ์ผ๋ก ๊ตฌ์ฑ๋๋ค. find(x) : x๋ฒ ๋ ธ๋์ root๋ฅผ ์ฐพ๋ ํจ์ link(x, y) : x ๋ ธ๋๊ฐ ์ํ ๊ทธ๋ฃน๊ณผ y ๋ ธ๋๊ฐ ์ํ ๊ทธ๋ฃน์ ํฉ์น๋(์ฐ๊ฒฐํ๋) ํจ์ ๋ํ ์ ์ฐ์ฐ์ ์ํด, parent[i] : i๋ฒ ๋ ธ๋์ ๋ถ๋ชจ๋ก ์ ์๋๋ ๋ฐฐ์ด์ด ์ฌ์ฉ๋๋ค. ์๋์ ๋ด์ฉ์ codeground ์ฌ์ดํธ์์ ๊ฐ์ ธ์จ ๋ด์ฉ Disjoint-Set ์๋ก์ ์งํฉ(Disjoint-Set)์ ์งํฉ, ํน์ ๊ทธ๋ฃน์ ๊ด๋ฆฌํ๋ ํจ์จ์ ์ธ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค. ๊ฐ๊ฐ์ ๊ทธ๋ฃน์ ํธ๋ฆฌ ๊ตฌ์กฐ๋ก ๊ด๋ฆฌํ๋ ์ด ์๊ณ ๋ฆฌ์ฆ์ ํฌ๊ฒ ๋ ๊ฐ์ง์ ์ฐ์ฐ์ ๊ฐ์ง๋๋ค. find(x): x๋ฒ ๋ ธ๋์ ์ต๊ณ ์กฐ์(๋ฃจํธ)์ ์ฐพ๋ ํจ์ ..
Dijkstra Algorithm ๊ทธ๋ํ์ ํ ๋ ธ๋์์ ๋ค๋ฅธ ๋ ธ๋๋ก ๊ฐ๋ ์ต๋จ๊ฑฐ๋ฆฌ๋ฅผ ๊ตฌํ๋ ์๊ณ ๋ฆฌ์ฆ (๋ง์ฝ ๋ชจ๋ ๋ ธ๋ ์๊ฐ์ ์ต๋จ๊ฑฐ๋ฆฌ๋ฅผ ๊ตฌํ ๋, n๊ฐ์ ๊ฐ ์ ์ ์ ๋ํด Dijkstra Alg๋ฅผ ์ฌ๋ฌ๋ฒ ์ํํด์ผํ๋ฏ๋ก, ์ด๋๋ Floyd-Warshall Alg์ด ๋ ์ ๋ฆฌํ๋ค) ๋์๊ณผ์ ์ BFS์ ๋น์ทํ์ง๋ง, Queue๊ฐ ์๋ Priority Queue๋ฅผ ์ด์ฉํ๋ค. ์๊ฐ๋ณต์ก๋=O(ElogE) ํด๋น๋ ธ๋๊น์ง์ ์ต๋จ๊ฑฐ๋ฆฌ๋ฅผ ์ ์ฅํ distance[] ๋ฐฐ์ด ์ค๋นํ, ๋ฏธ๋ฐฉ๋ฌธ์ ์๋ฏธํ๋ -1๋ก ์ด๊ธฐํํ๋ค. ๋ ธ๋1์์ ์์ํ๋ค๋ฉด, ์ด๋๊น์ง ์๊ธฐ์์ 1๊น์ง์ ๊ฑฐ๋ฆฌ๋ 0์ด๋ฏ๋ก distance[1]์ 0์, pq์ (1,0)์ ๋ฃ๋๋ค. 2์10๋ณด๋ค ๊ฐ๊น๋ค. distance[2]=8๋ก ๊ฐฑ์ , pq์๋ (2,8) ๋ฃ๋๋ค. pq์ (..
- Total
- Today
- Yesterday
- ๊ฐ๋ฐ์
- graph
- dfs
- bfs
- OneToMany
- Android Studio
- Algorithm
- Vo
- Android
- javascript
- ๋ฆฌ๋ฒ์ฑ
- queue
- reversing
- ํ๊ณ
- webhacking.kr
- mysql
- socket
- ์นํดํน
- C
- FRAGMENT
- Stack
- JPA
- ํด์ธ์ฌํ
- ์ฐ์ํ ํ ํฌ์ฝ์ค
- sort
- Data Structure
- git
- Java
- brute-force
- ํ๋ก๊ทธ๋๋จธ์ค
์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
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 |