๊ณ ์ ์ ์ํธํ ๋ฐฉ๋ฒ๊ณผ ํ๊ณ ์ผ๋ฐ์ ์ธ ๊ณผ์ ์ํธํ ๋ณตํธํ ์ Caesar Cipher ์๋ฌธ๊ณผ ์ซ์๋ฅผ ์ผ๋์ผ ๋์ ํ๋ฌธ์ ๋ฑ์ฅํ๋ ๋ชจ๋ ์ํ๋ฒณ์ ๋์ผํ ์นธ์๋งํผ ๋ฏธ๋ ๋ฐฉ์์ผ๋ก ์ํธํ ์ํ๋ฒณ์ด ์ด 26์ข
๋ฅ์ด๋ฏ๋ก, 26์ผ๋ก ๋๋ ๋๋จธ์ง๋ง์ ์๊ฐ Affine Cipher ํ๋ฌธ(Plaintext-P)์ ์ํธ๋ฌธ(Ciphertext-C)์ ๋ํ์ฌ ์ํธํ C = K_1 P + K_2 (mod 26) k1๊ณผ k2๋ฅผ ๊ธฐ์ค์ผ๋ก ํจ์๋ฅผ ๊ณ์ฐ ๊ณ ์ ์ ์ํธ ์ฒด๊ณ์ ๋ํ Brute-Force ๊ณต๊ฒฉ ๋ฌด์ฐจ๋ณ ๋์
๊ณต๊ฒฉ์ผ๋ก ๋ฌด๋ ฅํ๋ ์ ์์ ์์ธ์๋ถํด ๊ธฐ๋ฐ ์ํธ ์ฒด๊ณ Euler Phi Function ์์ฐ์ n์ ๋ํด n๋ณด๋ค ์์ผ๋ฉด์ n๊ณผ ์๋ก์์ธ ์์ฐ์์ ๊ฐ์๋ฅผ ํ์ด(n)์ผ๋ก ์ ์ ํ์ด(p) = p-1์์ ์๋ช
⇒ ์ฑ์ง ์์ฐ์ m๊ณผ n์ด..
๐ป ์ปดํจํฐ
๋์ ๊ณํ์ ์ดํด์ ๊ตฌํ Dynamic Programing ๋ณต์กํ ๊ผด์ ๊ฐ์ง ๋ฌธ์ ๋ฅผ ๋ณด๋ค ๋จ์ํ ์ฌ๋ก ๋ฌธ์ ๋ก ์ชผ๊ฐ์ด ํด๊ฒฐ ‘๊ณผ๊ฑฐ์ ๊ณ์ฐํ์๋ ๊ฒฐ๊ณผ๋ฅผ ํ์ธ’ ‘์ ํ์์ ์ธ์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋’ ํํ๋ก ํ์ฉ ex - a(n+1) = a(n) + 2 ์ ๊ฐ์ ์ ⇒ ๋ถํ์ํ ๋ฐ๋ณต์ ์ธ ํ์๋ฅผ ์ต์ํํ๋ ๊ฒ์ด ๋ชฉํ ( Memoization or Tabulation - ์ค๊ฐ๊ฐ ๊ธฐ๋ก ) Memoization ์) ํผ๋ณด๋์น ์์ด def ex_func(N): if (fibo_list[N] != -1): return fibo_list[N] else: fibo_list[N] = ex_func(N-1) + ex_func(N-2) return fibo_list[N] N = int(input()) fibo_list = [-1 for..
์ฌ๊ท์ ์ ๊ทผ์ ์๋ฆฌ์ ์ค์ Recursion ์ฌ๊ท์ ํธ์ถ ๋ถํ์ ๋ณต ํจ๋ฌ๋ค์ ๊ตฌํ์ ๋ง์ด ์ฐ์ bottom-up๊ณผ top-down์ผ๋ก ๊ตฌ๋ถ ๊ฐ๋ฅ, ์ฌ๊ท๋ top-down์ ํด๋น ๋ถํ์ ๋ณต์ ์ดํด ํ๊ณ ์ ํ๋ ๋ฌธ์ ๋ฅผ ์์ ํฌ๊ธฐ๋ก ๋ถํ ์ถฉ๋ถํ ๋ฌธ์ ๊ฐ ์์์ง ๊ฒฝ์ฐ → ์ ๋ณต ์์ ๊ฐ๋ณ ๋ฌธ์ ๋ค์ ๋ํ ํด๋ฅผ ํตํฉํ๋ ๊ณผ์ ์ ๊ฑฐ๋ญํ์ฌ ์ต์ข
ํด ๋์ถ Sequential Search - ๋ฌด๋๋ฝ Binary Search - ‘๋ถํ์ ๋ณต ํจ๋ฌ๋ค์’์ ์ํจ n → logn์ผ๋ก ์ค์ด๋ ๋ฐฉ๋ฒ๋ ์์ (์ง์๋ฅผ ์ชผ๊ฐ๋ฉด์) ๋ถํ์ ๋ณต์ ์ด์ฉํ ์ ๋ ฌ Merge Sort ์์ด์ด ์ฃผ์ด์ง ๋, ์์ด์ ์ ๋ฐ์ผ๋ก ์ชผ๊ฐ๋ ๊ณผ์ ๋ฐ๋ณต ๋์ด์ ์ชผ๊ฐค ์ ์๋ ๊ฒฝ์ฐ, ์ด๋ฏธ ์ชผ๊ฐ์ง ์์ด์ ์์์ ๋ง์ถฐ ํฉ์น๋ ๊ณผ์ ์ํ ๊ณ์ ์ชผ๊ฐ๋ ๊ณผ์ ์งํ ์ดํ ์์๋ฅผ ๋ง์ถ๋ฉฐ ..
์ ๋ ฌ์ ์ฑ๋ฅ๊ณผ ์๊ฐ๋ณต์ก๋ Heap sort Max Heap ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ด์ฉ ๋น์ด์๋ Heap์ ์ฃผ์ด์ง ์์๋ฅผ ์์๋๋ก ์ฝ์
, ๊ทธ๋๋ Heap ์ฑ์ง์ด ์ ์ง๋๋๋ก Heap ์ต์๋จ์๋ ์ต๋๊ฐ์ด ์กด์ฌํจ์ด ๋ณด์ฅ, ์์ด์ ๋งจ ๋์ Heap ์ต์๋จ ๊ฐ์ ์์น Heap ์ต์๋จ ์์๋ฅผ ์ ๊ฑฐํ ํ, Heap ์ฑ์ง์ ์ ์งํ๋ฉฐ ๋์ผํ ๊ณผ์ ๋ฐ๋ณต ์ฆ, N๊ฐ ์์ ์ฝ์
- Heap์ด ๋ค์ ๋น ๋๊น์ง ๋ฐ์ดํฐ N๊ฐ ์ ๊ฑฐ (nlogn - ๋
ธ๋์ ๋์ด๊ฐ ์ค์ํจ) Heap ๊ตฌ์ฑํ๋ ์๊ฐ ๋ณต์ก๋ - log1 ~ logn ์ ๊ฑฐํ๋ฉฐ ์ ๋ ฌํ๋ ์๊ฐ๋ณต์ก๋ -logn ~ log1 → log(n!) ๋น
O ๋ฐฉ๋ฒ์ ํตํด์ T(n)์ด nlogn๋ณด๋ค๋ ์๋ค๋ ๊ฑธ ์ ์ ์์ ๋น
์ค๋ฉ๊ฐ ๋ฐฉ๋ฒ์ ํตํด์ T(n)์ด nlogn๋ณด๋ค๋ ํฌ๋ค๋ ๊ฑธ ์ ์ ์์ ๋น
O..
์์ฐจ ํ์๊ณผ ์ด์ง ํ์ ์์ฐจํ์ ์ฒซ ๋ฒ์งธ ์์๋ถํฐ ์์ฐจ์ ์ผ๋ก ํ์ธ ์ด์งํ์ (์ ๋ ฌ์ด ์ด๋ฏธ ์ด๋ฃจ์ด์ง ๊ฒฝ์ฐ) ์ค์์ ๊ธฐ์ค์ผ๋ก ๋ฐ์ผ๋ก ์ชผ๊ฐ์ด ๋์๋ฅผ ๋น๊ตํ์ฌ ์ํ๋ ์๊ฐ ์ํ ๋ถ๋ถ์ ํ์ธ Log_2 (n)์ ์๋ฅผ ๊ฐ์ง nubers = [15, 19, 22, 33, 44, 55, 66, 77, 88, 99] target = 33 left = 0 right = len(nubers) - 1 while (1): mid = (left + right) // 2 if nubers[mid] == target: print("find it") break elif nubers[mid] > target: right = mid - 1 else: left = mid + 1 if left > right: print("not find")..
์ด ์๋ฆฌ์ฆ๋ ๊ณ ๋ ค๋ํ๊ต ์ ๋ณด๋ํ '์ ์ฉ์ฌ ๊ต์๋'์ ์์
์ ๋ฃ๊ณ ์ ๋ฆฌํ ์๋ฃ์
๋๋ค. ๊ฐ์ธ์ ์ผ๋ก ๊ต์ฅํ ์กด๊ฒฝํ๋ ๋ถ์ด๋ฉฐ, ๋ ์์๋ณด๊ณ ์ถ์ผ์ ๋ถ์ ์๋ ๋งํฌ๋ฅผ ์ฐธ๊ณ ํด์ฃผ์ธ์. https://yooy.mystrikingly.com/ ์๊ฐ๋ณต์ก๋, ๊ณต๊ฐ๋ณต์ก๋ ์๊ณ ๋ฆฌ์ฆ ์ฃผ์ด์ง ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํ ๋จ๊ณ์ ์ ์ฐจ ํน์ ๋ฐฉ๋ฒ ๋ชจํธ์ฑ์ด ์๊ณ ์คํ ๊ฐ๋ฅํ๋ฉฐ ์ข
๊ฒฐ์ด ์ด๋ฃจ์ด์ง๋ ์ ์ฐจ์ ์งํฉ ์๊ฐ๋ณต์ก๋ ์ด๋ค ํ๋ก๊ทธ๋จ์ด ์์ํ๋ ์๊ฐ์ ๋ํ๋ด๋ ๊ฐ๋
์๊ฐ๋ณต์ก๋(TC) = (์ปดํ์ผ ์๊ฐ) c + (์คํ ์๊ฐ) T(n) ํ๋ก๊ทธ๋จ ๋ถ์์์ ์ผ๋ฐ์ ์ผ๋ก ‘์คํ ์๊ฐ’์ด ‘์ปดํ์ผ ์๊ฐ’๋ณด๋ค ์ค์ ๊ณต๊ฐ๋ณต์ก๋ ๋๋ฆฌ๋๋ฐ ํ์ํ ์์(๋ฆฌ์์ค) ์๊ฐ > ๊ณต๊ฐ (์ค์์ฑ) ‘์ฐ์ฐ ํ์’๊ฐ ์ค์ ๋ฐ๋ณต์ด ์๋ ๋จ์ ๋ณ์ ์ ์ธ ๋ฑ์ ๋ฌด์ ์ค์ง์ ์ผ๋ก ๋๋๊ฑฐ๋ ..