Algorithm


1. ์ด์ ์ง์์ RGB ์ค์์ ์ ํํ ์์ ์ ์ฅํด๋๋๋ค. 2. ํ์ฌ ์ง์ ์์น ํ ๋, ์ด์ ์ง์์ ์ ํํ ์๊ณผ ๊ฐ์ง ์์ ๊ฒ ์ค ์ต์๊ฐ์ธ ์์ ์น ํ๋ค. → F[k] = F[k-1] + Min( ์ด์ ์ง์์ ์ ํํ ์๊ณผ ๊ฐ์ง ์์ ๊ฒ๋ค ) ์์ ์ฒ๋ผ ํ๊ฒ๋๋ฉด ๊ฐ์ฅ ์์ ๋ฌธ์ ์ธ F(1)์ด ๋ช ํํ์ง ์์์ง๋ค๋ ๋ฌธ์ ๊ฐ ์๊ธด๋ค... ๊ทธ๋ฆฌ๊ณ ํ์ฌ์ ์ ํ์ด ์ต์๊ฐ์ด๋๋ผ๋ ์ ์ฒด์ ํด๊ฐ ์ต์๊ฐ ๋๋ค๋ ๋ณด์ฅ์ ํ ์ ์๋ค...ใ F[k][0] = Min(F[k-1][1], F[k-1][2] ) + RGB[k, 0]; F[k][1] = Min(F[k-1][0], F[k-1][2] ) + RGB[k, 1]; F[k][2] = Min(F[k-1][0], F[k-1][1] ) + RGB[k, 2]; ํ์ฌ ์ง์ ์์น ํ ๋ RG..


์ ๊ทผ๋ฐฉ๋ฒ์ ์์ ๋ชป ์ฐพ๊ฒ ๋ ๋ฌธ์ ...! ๊ฑฐ์ 1์๊ฐ 30๋ถ๋์ ๋ฉ ๋๋ฆฌ๊ณ ์์๋ค...ใ ใ ์๋ ์น์ฆ ๋ชจ์์์ (0, 7)์ c๋ฅผ ๊ธฐ์ค์ผ๋ก ํ๋ฐฉ ํ์์ ํตํด c๊ฐ ๋๋ ์ขํ๋ฅผ ๋ชจ๋ ์ฐพ์ bfs๋ฅผ ๋๋ฆด ์๊ฐ์ด์๋๋ฐ... ๋์ ํ c๊ฐ ๋๋ ์ขํ๋ฅผ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ ๋ชป์ฐพ์๋ค... ์๊ณ ๋ณด๋ ์น์ฆ๋ฅผ ํ์ํ๋ ๊ฒ ์๋ ๊ณต๊ธฐ๋ฅผ ํ์ํ๋ ๋ฐฉ๋ฒ์ผ๋ก ์ ๊ทผํ์ด์ผ ํ๋ค. (0,0)์ ๊ธฐ์ค์ผ๋ก ๋ชจ๋ ๊ณต๊ธฐ๋ฅผ ํ์ํด ๋๊ฐ๋ฉด์ ์ฃผ๋ณ์ ์น์ฆ๊ฐ ์์ผ๋ฉด ๋ น์ด๋ ๋ฐฉ์... ๊ทธ๋ฌ๋ฉด ์น์ฆ ๋ด๋ถ์ ๊ตฌ๋ฉ๋ ๋ฐ๋ก ์๊ฐ ์ ํด๋ ๋๊ณ ...!! ์ค๋ช ๋ฃ์๋ง์ ์ ๋ ์นด ๊ทธ ์์ฒด ๊ทธ๋ํ ํ์ ๊พธ์คํ ๊ณต๋ถํด์ผ์ง...ํํ ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ๋ค. import java.io.BufferedReader; import java.io.IOException; import ja..


1. Arrays.sort() API๋ฅผ ํ์ธํด๋ณด๋ฉด Arrays.sort()๋ Dual-Pivot Quicksort ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ๊ตฌํ๋์๋ค๊ณ ํ๋ค. Dual-Pivot Quicksort๋ ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ 17๋ณด๋ค ์์ผ๋ฉด Insertion Sort๋ฅผ ์ํํ๊ณ , ์๋๋ฉด ๋๊ฐ์ pivot์ ๊ฐ์ง๋ dual-pivot quicksort๋ฅผ ์ํํ๋ค๊ณ ํ๋ค. ์๊ฐ๋ณต์ก๋๋ ํ๊ท O(n log n), ์ต์ ์ผ ๋๋ O(n^2) ๊ฐ์ง๋ค. [์ฐธ๊ณ ] https://stackoverflow.com/questions/20917617/whats-the-difference-of-dual-pivot-quick-sort-and-quick-sort 2. Collections.sort() Collections.sort()๋ List.sort(..


์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ์๊ฐ, ๊ณต๊ฐ ๋ณต์ก๋ ๋น๊ต 1. ์ฝ์ ์ ๋ ฌ(Insertion Sort) public static void insertionSort(int[] arr) { for(int i = 1; i = 0 && arr[index] > curr) { arr[index+1] = arr[index]; index--; } arr[index+1] = curr; System.out.println(" " + Arrays.toString(arr)); } } ์ต์ ์ธ ๊ฒฝ์ฐ : ์ด๋ฏธ ์ ๋ ฌ์ด ๋ ์ํ์ผ ๋ - [ 1, 2, 3, 4, 5 ] while๋ฌธ์ arr[index] > arr์ ์กฐ๊ฑด๋ง ํ์ธํ๊ณ ,..


ํ(Heap) : ์์ ์ด์งํธ๋ฆฌ์์ ๋ค์์ ๋ง์กฑํ๋ ๊ฒ์ ๋งํ๋ค. ๋ง๋์ ์ ์ฅ๋ ๊ฐ์ ์์๋ฅผ ๋งค๊ธธ ์ ์๋ ์์์ด๋ค. ๊ฐ ๋ง๋์ ์ ์ฅ๋ ๊ฐ์ ๊ทธ์ ์์๋ง๋์ ์ ์ฅ๋ ๊ฐ๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๋ค. → ํ ์ฑ์ง(heap property) ํ ์ ๋ ฌ (Heap Sort) : ์ต๋ ํ ํธ๋ฆฌ๋ ์ต์ ํ ํธ๋ฆฌ๋ฅผ ๊ตฌ์ฑํด ์ ๋ ฌ์ ํ๋ ๋ฐฉ๋ฒ์ ๋งํ๋ค. ํ ์ ๋ ฌ ๊ณผ์ ์ด๊ธฐ๋ฐฐ์ด์ ์ํ๊ฐ ์์ ๊ฐ๋ค๊ณ ํด๋ณด์. ๋ฐฐ์ด์ ์์ ์ด์ง ํธ๋ฆฌ๋ก ๊ทธ๋ ค๋ณด๋ฉด ์์ ๊ฐ๋ค. ์์ ํธ๋ฆฌ๋ ์์ง ํ์ ์๋๋ฏ๋ก ์ ๋ ฌ์ ํตํด ์ต๋ ํ์ ๋ง๋ค์ด ๋ณผ ๊ฒ์ด๋ค. ๊ฐ์ฅ ํ์์ ์๋ธํธ๋ฆฌ๋ฅผ ๋ณด๋ฉด 3์ ์์์ธ 10๋ณด๋ค ์๊ณ , 1์ ์์์ธ 8๋ณด๋ค ์๋ค. ๋ฐ๋ผ์ 3๊ณผ 10, 1๊ณผ 8์ ๊ต์ฒดํ์ฌ ์ ๋ ฌํ๋ค. ๊ทธ๋ฌ๋ฉด ๊ฐ์ฅ ํ์์ ์๋ธํธ๋ฆฌ์ ๋ํด์๋ ํ์ด ์์ฑ๋์๋ค. ๊ทธ ๋ค์ ๋ฃจํธ์ ์ผ..


๋ถ๋ค๋ถ๋ค....์๊ฐ์ด๊ณผ๋ก 6๋ฒ ์คํจํ๊ณ ๊ฒจ์ฐ ๋ง์ถ ๋ฌธ์ ... ๋ฌธ์ ๋ง ์ฝ๊ณ ๋ ์ฌ์ด ํธ์ธ ์ค ์์๋๋ฐ... ์ฐ์ ํฌ๋ ์ธ์ ๋ฌด๊ฒ ์ ํ๊ณผ, ๋ฐ์ค๋ค์ ๋ฌด๊ฒ๋ฅผ ๋ฆฌ์คํธ์ ์ ์ฅ ํ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ ๋ค์ ์ ์ผ ๋ฌด๊ฑฐ์ด ๋ฌด๊ฒ๋ฅผ ๋ค ์ ์๋ ํฌ๋ ์ธ์ด ๊ฐ์ฅ ๋ฌด๊ฑฐ์ด ๋ฐ์ค๋ฅผ ๋ชป ๋ค ๊ฒฝ์ฐ์๋ -1์ถ๋ ฅ ํ ํ๋ก๊ทธ๋จ ์ข ๋ฃ. ํฌ๋ ์ธ์ด j๋ฒ์งธ ๋ฐ์ค๋ฅผ ๋ค ์ ์์ผ๋ฉด ๋ฆฌ์คํธ์์ ์ญ์ ํฌ๋ ์ธ์ด j๋ฒ์งธ ๋ฐ์ค๋ฅผ ๋ค ์ ์์ผ๋ฉด j++ ์ฒ์์ ํฌ๋ ์ธ ๋ฆฌ์คํธ๋ ์กฐํ๋ง ์ด๋ฃจ์ด์ง๊ธฐ ๋๋ฌธ์ ๋ฐฐ์ด์ ์ ์ฅ์ ํ์๊ณ , ๋ฐ์ค ๋ฆฌ์คํธ๋ ์ญ์ ๊ฐ ๋น๋ฒํ๊ฒ ์งํ๋๋ค๊ณ ์๊ฐํ์ฌ LinkedList๋ก ์ ์ฅํ์๋ค. → BufferedReader + LinkedList ์กฐํฉ → ์คํจ!!! (์๋ฌด๋๋ while - for - for ๋ก ์๊ฐ์ด๊ณผ๊ฐ ๋น์ฐํ...) ๊ณ์ ํ๋ฆฌ๋ค๊ฐ ..


ํต์ ๋ ฌ(Quick Sort) : ๋ฐฐ์ด์์ ํ๋์ ๊ฐ์ ๊ธฐ์ค์ผ๋ก(pivot) ์์๋ ๊ธฐ์ค๊ฐ๋ณด๋ค ์์ ์์๋ค, ๋ค์๋ ๊ธฐ์ค๊ฐ๋ณด๋ค ๋์ ์์๋ค์ด ์ค๋๋ก ์ ๋ ฌํ๋ ์๊ณ ๋ฆฌ์ฆ(๋ถํ ์ ๋ณต) ๋ฆฌ์คํธ์์ ํ๋์ ์์๋ฅผ ๊ณ ๋ฅธ๋ค. → ๊ธฐ์ค๊ฐ(Pivot), ์์๋ฅผ ๊ณ ๋ฅด๋ ๊ธฐ์ค์ ๋ฐ๋ก ์๋ค. ๋ค๋ง ๋ณดํต ๊ฐ์ด๋ฐ ์์๋ฅผ ๊ณ ๋ฅด๋ ํธ. ๊ธฐ์ค๊ฐ ์์๋ ๊ธฐ์ค๊ฐ๋ณด๋ค ์์ ์์๋ค, ๋ค์๋ ๊ธฐ์ค๊ฐ๋ณด๋ค ๋์ ์์๋ค๋ก ๋ฆฌ์คํธ๋ฅผ ๋๊ฐ๋ก ๋๋๋ค.(๋ถํ ) ๋ถํ ๋ ๋ฆฌ์คํธ๊ฐ 0 ๋๋ 1์ด ๋๋ค๋ฉด ์ ์ฒด์ ์ผ๋ก ๋ดค์ ๋ ๋ฆฌ์คํธ๋ ์ ๋ ฌ๋ ์ํ๊ฐ ๋๋ค. ํต ์ ๋ ฌ ๊ณผ์ ํต์ ๋ ฌ ์ฝ๋(Java) public static void quickSort(int start, int end, int[] arr) { int i, j, pivot; if(start < end) { pi..


ํฉ๋ณ์ ๋ ฌ(Merge Sort) : ์ ๋ ฌ๋์ง ์์ ๋ฆฌ์คํธ๋ฅผ ๊ฐ๊ฐ ํ๋์ ์์๋ง ํฌํจํ๋ n๊ฐ์ ๋ถ๋ถ๋ฆฌ์คํธ๋ก ๋ถํ ํ๊ณ ๋ถ๋ถ๋ฆฌ์คํธ๊ฐ ํ๋๋ง ๋จ์ ๋๊น์ง ๋ฐ๋ณตํด์ ๋ณํฉํ๋ฉฐ ์ ๋ ฌ๋ ๋ถ๋ถ๋ฆฌ์คํธ๋ฅผ ์์ฑํ๋ ์๊ณ ๋ฆฌ์ฆ (๋ถํ ์ ๋ณต ์๊ณ ๋ฆฌ์ฆ) → ํํ ์ฌ์ฉํ๋ 2-way ํฉ๋ณ์ ๋ ฌ ์ ๋ ฌ๋์ง ์์ ๋ฆฌ์คํธ๋ฅผ 2๊ฐ์ ๋ถ๋ถ๋ฆฌ์คํธ๋ก ๋ถํ (Divide) ๋ถ๋ถ๋ฆฌ์คํธ๋ค์ ์์๊ฐ 1๊ฐ์ผ ๋๊น์ง ๋ถํ ๊ณ์ ์งํ ๋๊ฐ์ ๋ถ๋ถ๋ฆฌ์คํธ๋ฅผ ํ๋์ ์ ๋ ฌ๋ ๋ฆฌ์คํธ๋ก ํฉ๋ณํ๋ค. (Conquer) ์ต์ข ๋ถ๋ถ๋ฆฌ์คํธ๊ฐ 1๊ฐ๊ฐ ๋ ๋๊น์ง ํฉ๋ณ ๊ณ์ ์งํ ํฉ๋ณ์ ๋ ฌ ๊ณผ์ ํฉ๋ณ์ ๋ ฌ ์ฝ๋(Java) public static void mergeSort(int start, int end, int[] arr) { if(end-start == 1) { // ๋ถ๋ถ๋ฆฌ์คํธ์ ์์๊ฐ..


1. ์ฝ์ ์ ๋ ฌ(Insertion Sort) : ์๋ฃ ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ ์์์๋ถํฐ ์ฐจ๋ก๋๋ก ์ด๋ฏธ ์ ๋ ฌ๋ ๋ฐฐ์ด ๋ถ๋ถ๊ณผ ๋น๊ตํ์ฌ, ์์ ์ ์์น๋ฅผ ์ฐพ์ ์ฝ์ ํ๋ ์๊ณ ๋ฆฌ์ฆ → i๋ฒ์งธ ๋ฐ์ดํฐ๋ฅผ ์์ชฝ ๋ฐ์ดํฐ์ ๋น๊ตํ์ฌ ์๋ง์ ์๋ฆฌ์ ์ฝ์ ํด์ฃผ๋ ๋ฐฉ๋ฒ 8, 10, 9, 7, 3 ์์ ๊ฐ์ ๋ฐฐ์ด์ด ์๋ค๊ณ ํ์. ๋ชจ๋ ๋ฐฐ์ด์ด ์ ๋ ฌ์ด ์๋์ด ์์ผ๋ฏ๋ก ๋งจ ์์ด ์๋ ๋ ๋ฒ์งธ ์์๋ถํฐ ํ์ธ์ ํ๋ค. 8, 10, 9, 7, 3 ๋ ๋ฒ์งธ ์์์ธ 10์ ์ฒซ ๋ฒ์งธ ์์ 8๊ณผ ๋น๊ต๋ฅผ ํ๋ฉด 8์ ์ค๋ฅธ์ชฝ์ ์์นํด์ผ ํ๋ ๊ฒ์ด ๋ง์ผ๋ฏ๋ก ์์น๋ฅผ ๋ณ๊ฒฝํ์ง ์๊ณ ๊ทธ๋๋ก ๋ด๋ฒ๋ ค๋๋ค. 10์ ์๋ฆฌ๊ฐ ๊ฒฐ์ ๋์์ผ๋ฏ๋ก ๋ค์ ์์๋ฅผ ์ ๋ ฌํ๋ค. 8, 10, 9, 7, 3 ์ธ ๋ฒ์งธ ์์์ธ 9๋ ๋ ๋ฒ์งธ ์์ 10๊ณผ ๋น๊ต๋ฅผ ํ๋ฉด 10์ ์ผ์ชฝ์ ์์นํด์ผ ํ๋ ๊ฒ์ด..