์๊ณ ๋ฆฌ์ฆ
-
BOJ-16139 [C++] ์ธ๊ฐ-์ปดํจํฐ ์ํธ์์ฉ
๋ฌธ์ ์น์ฌ๋ ์ธ๊ฐ-์ปดํจํฐ ์ํธ์์ฉ์์ ์์ฒด๊ณตํ ์ค๊ณ๋ฅผ ๊ณต๋ถํ๋ค๊ฐ ํค๋ณด๋ ์ํ์ด ์ค์ฉ์ ์ธ์ง ๊ถ๊ธํด์ก๋ค. ์ด๋ฅผ ์์๋ณด๊ธฐ ์ํด ์น์ฌ๋ ๋ค์๊ณผ ๊ฐ์ ์๊ฐ์ ํ๋ค. '๋ฌธ์์ด์์ ํน์ ์ํ๋ฒณ์ด ๋ช ๋ฒ ๋ํ๋๋์ง ์์๋ด์ ์์ฃผ ๋ํ๋๋ ์ํ๋ฒณ์ด ์ค์ง๋ ๊ฒ์ง ์์น์ ์ค๋ ์ํ๋ฒณ์ธ์ง ํ์ธํ๋ฉด ์ค์ฉ์ ์ธ์ง ํ์ธํ ์ ์์ ๊ฒ์ด๋ค.' ์น์ฌ๋ฅผ ๋์ ํน์ ๋ฌธ์์ด S, ํน์ ์ํ๋ฒณ ฮฑ์ ๋ฌธ์์ด์ ๊ตฌ๊ฐ [l,r]์ด ์ฃผ์ด์ง๋ฉด S์ l๋ฒ์งธ ๋ฌธ์๋ถํฐ r๋ฒ์งธ ๋ฌธ์ ์ฌ์ด์ ฮฑ๊ฐ ๋ช ๋ฒ ๋ํ๋๋์ง ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ฌ๋ผ. ์น์ฌ๋ ๋ฌธ์์ด์ ๋ฌธ์๋ 0๋ฒ์งธ๋ถํฐ ์ธ๋ฉฐ, l๋ฒ์งธ์ r๋ฒ์งธ ๋ฌธ์๋ฅผ ํฌํจํด์ ์๊ฐํ๋ค. ์ฃผ์ํ ์ ์ ์น์ฌ๋ ํธ๊ธฐ์ฌ์ด ๋ง๊ธฐ์ (ํต๊ณ์ ์ผ๋ก ํฌ๊ฒ ๋ฌด์๋ฏธํ์ง๋ง) ๊ฐ์ ๋ฌธ์์ด์ ๋๊ณ ์ง๋ฌธ์ q๋ฒ ํ ๊ฒ์ด๋ค. ์ ๋ ฅ ์ฒซ ์ค์ ๋ฌธ์์ด ..
0 2023.01.10 -
Algorithm ๋ฐฑํธ๋ํน(Backtracking)
๋ฐฑํธ๋ํน(Backtracking) ๊ฐ๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ณ ๋ คํ๋ ์๊ณ ๋ฆฌ์ฆ ์ํ ๊ณต๊ฐ์ ํธ๋ฆฌ(Tree)๋ก ๋ํ๋ผ ์ ์์ ๋ ์ ํฉํ ๋ฐฉ์์ด๋ค. ์ผ์ข ์ ํธ๋ฆฌ ํ์ ์๊ณ ๋ฆฌ์ฆ(Tree Search Algorithm)์ด๋ผ๊ณ ๋ด๋ ๋๋ค. ๋ฐฉ์์ ๋ฐ๋ฅธ ๋ถ๋ฅ ๊น์ด ์ฐ์ ํ์(Depth First Search, DFS) ๋๋น ์ฐ์ ํ์(Breadth First Search, BFS) ์ต์ ์ฐ์ ํ์(Best First Search / Heuristic Search) ๊ฒฝ์ฐ์ ์ ๊ตฌํ๊ธฐ๋ ์ผ๋ฐ์ ์ผ๋ก DFS๊ฐ ํธ๋ฆฌํ๋ฉฐ, ๋๋ค์์ ๋ฌธ์ ๋ค์ DFS๋ฅผ ์จ๋ ์ผ๋จ ๋ต์ ๋์จ๋ค. ํ์ง๋ง, ํธ๋ฆฌ์ ๊น์ด(Depth)๊ฐ ๋ฌดํ๋๊ฐ ๋ ๊ฒฝ์ฐ์๋ DFS๋ฅผ ์ฌ์ฉํ๋ฉด ์๋๋ค. ์) ๋ฏธ๋ก ์ฐพ๊ธฐ์์ ๋ฃจํ(ํ๋ก)๊ฐ ๋ฐ์ํ๋ ๊ฒฝ์ฐ, DFS๋ ์ด ๊ฐ์ง๋ฅผ ..
0 2022.11.16 -
Algorithm ์ต๋ ๊ณต์ฝ์(GCD)์ ์ต์ ๊ณต๋ฐฐ์(LCM) ; ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ(Euclidean Algorithm)
์ต๋ ๊ณต์ฝ์(GCD)์ ์ต์ ๊ณต๋ฐฐ์(LCM) ; ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ(Euclidean Algorithm) ์ต๋ ๊ณต์ฝ์(GCD; Greatest Common Divisor(Factor)) ๋ ๊ฐ ์ด์์ ์์ฐ์๋ค์ ๊ณตํต์ธ ์ฝ์๋ค์ ๋ชจ์์ ๊ณต์ฝ์(Common Divisor)๋ผ๊ณ ํ๊ณ , ๊ณต์ฝ์ ์ค์์ ๊ฐ์ฅ ํฐ ์๋ฅผ ์ต๋ ๊ณต์ฝ์(Greatest Common Divisor)๋ผ๊ณ ํ๋ค. ์) 12์ ์ฝ์๋ {1,2,3,4,6,12} ์ด๊ณ 18์ ์ฝ์๋ {1,2,3,6,9,18}์ผ ๋, ๋ ์ 12์ 18์ ๊ณต์ฝ์๋ {1,2,3,6}์ด๊ณ ์ต๋ ๊ณต์ฝ์๋ 6์ด ๋๋ค. ์ฝ๋ int gcd(int x, int y) { for (int i = (x > y ? y : x..
0 2022.11.13 -
Algorithm ๋ธ๋ฃจํธ ํฌ์ค(Brute Force)
๋ธ๋ฃจํธ ํฌ์ค(Brute Force) ๊ฐ๋ ๋ธ๋ฃจํธ(Brute)์ ํฌ์ค(Force)๊ฐ ๊ฒฐํฉ๋์ด ๋ง๋ค์ด์ง ๋จ์ด์ด๋ฉฐ, "๋ํญํ ํ(ํญ๋ ฅ)" ์ด๋ผ๋ ๋ป์ด๋ค. ๋ฌธ์ ํด๊ฒฐ์ ์ํด ์ค๋ ๊ฑธ๋ฆฌ๊ณ ์์์ด ๋ง์ด ๋ค์ด์ ๋ฌด์ํ๋ค๊ณ ์๊ฐ๋ ์๋ ์์ง๋ง, ํญ์ 100%์ ์ ํ์ฑ์ ๋ณด์ธ๋ค. ์ ๋ต(Solution)์ด ๋ฐ๊ฒฌ๋ ๋๊น์ง ๊ฐ๋ฅํ ๋ชจ๋ ์ ํ์ง๋ฅผ ์ฐพ๋ ๋ฐฉ๋ฒ์ด๋ค. ์) 4์๋ฆฌ ์ซ์์ ํจ์ค์๋๋ฅผ ์ฐพ๊ธฐ ์ํด 0000๋ถํฐ 9999๊น์ง ํ๋์ฉ ์ ๋ ฅํ์ฌ ์ฐพ์๋ณด๋ ๊ฒฝ์ฐ ๋ฐ๋ผ์ ๋ธ๋ฃจํธ ํฌ์ค ์๊ณ ๋ฆฌ์ฆ์ ์์ ํ์ ์๊ณ ๋ฆฌ์ฆ์ด๋ผ๊ณ ํ ์ ์๋ค. ๊ฐ๋จํ๊ณ ์ผ๊ด์ ์ด์ง๋ง, ๋งค์ฐ ๋๋ฆฌ๋ค๋ ๋จ์ ์ด ์๋ค. ๊ฑฐ์ ์๋ฒฝํ๊ฒ ๋ณ๋ ฌ ์์ ์ด ๊ฐ๋ฅํ์ฌ ๋ณ๋ ฌ ํ๋ก๊ทธ๋๋ฐ์์ ์ฌ์ฉ๋๋ค. ํจํด ๋งค์นญ(Pattern Matching) ๋ฑ์ ์์ ์ ์ฌ์ฉ๋ ์ ์๋ค. ๋๋น ์ฐ์ ํ..
0 2022.11.03 -
Algorithm ํ๋ ธ์ด ํ(Tower of Hanoi)
ํ๋ ธ์ด ํ(Tower of Hanoi) ๊ฐ๋ ํ๋์ค์ ์ํ์ ์๋์๋ฅด ๋คผ์นด(Franรงois รdouard Anatole Lucas)๊ฐ 1883๋ ์๊ฐํ ์ ๋ช ํ ๋ฌธ์ ์ฌ๊ท(Recursion)๋ฅผ ์ฐ์ตํ๋๋ฐ ๋์์ด ๋๋ ์๊ณ ๋ฆฌ์ฆ ๋ค์๊ณผ ๊ฐ์ด 3๊ฐ์ ๋ง๋์ N๊ฐ์ ์ํ(Disk)์ด ์์ ๋, ์ํ์ ๋ค์์ ์์๋ฅผ ์งํค๋ฉด์ A์์ C๋ก ์ฎ๊ธฐ๋ ์์ ๊ฐ ์ํ์ ํฌ๊ธฐ๋ ๋ชจ๋ ๋ค๋ฅด๋ค. ์ํ์ ํฌ๊ธฐ๋ ์๋์์๋ถํฐ ์๋ก ๊ฐ์๋ก ์ ์ ์์์ง๋ค. โ ํ ๋ฒ์ ํ๋์ ์ํ๋ง ์ด๋ํ๋ค. โก ๋งจ ์์ ์๋ ์ํ๋ง ์ด๋ํ๋ค. โข ํฌ๊ธฐ๊ฐ ์์ ์ํ ์์ ํฐ ์ํ์ ์์ ์ ์๋ค. ์ด ์กฐ๊ฑด์์ ๋ค์์ ๊ตฌํ๋ ๊ฒ์ด ํ๋ ธ์ด ํ์ ๋ฌธ์ ๊ฐ ๋๋ค. โ ์ต์์ ์ด๋ ํ์๋ก ์ฎ๊ธฐ๋ ๊ฐ์ง์ (2Nโ1) โก ์ต์์ ์ด๋ ํ์๋ก ์ฎ๊ธธ ๋, ..
0 2022.11.03 -
Algorithm ์ค์บ๋ ๋ฉ์๋(Scanning Method)
์ค์บ๋ ๋ฉ์๋(Scanning Method) ์ผ๋ ฌ๋ก ๋์ด๋ ๋ฐ์ดํฐ๊ฐ ์ฃผ์ด์ง ๋, ๋ฌธ์ ์์ ์๊ตฌํ๋ ์ด๋ค ํน์ ๊ตฌ๊ฐ๊ณผ ๊ทธ ๊ตฌ๊ฐ์ ๊ธธ์ด๋ฅผ ๊ตฌํ๊ณ ์ ํ ๋๊ฐ ์๋ค. ์ ์๋์ ๊ฐ์ด ๋ฐฐ์ด a์ 0 ๋๋ 1์ ๋ฐ์ดํฐ๊ฐ ์ฃผ์ด์ง ๋, ์ฐ์์ ์ผ๋ก 1์ด ๋ฐ์๋๋ ์ต๋ ๊ตฌ๊ฐ์ ๊ธธ์ด์ ๊ทธ ๋์ ์์น๋ฅผ ๊ตฌํ๋ผ. X 1 0 1 1 0 1 1 1 1 0 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a[10] ๊ตฌ๊ฐ [1, 1]์๋ ์ฐ์๋ 1์ด 1๊ฐ ๋ฐ์๋์๊ณ , ๊ตฌ๊ฐ [3, 4]์๋ ์ฐ์๋ 1์ด 2๊ฐ ๋ฐ์๋์์ผ๋ฉฐ ๊ตฌ๊ฐ [6, 9]์๋ ์ฐ์๋ 1์ด 4๊ฐ ๋ฐ์๋์๋ค. ์ฌ๊ธฐ์ ์ฐ์์ ์ผ๋ก 1์ด ๋ฐ์๋๋ ์ต๋ ๊ตฌ๊ฐ์ [6, 9]์ด๊ณ , ๊ตฌ๊ฐ์ ๊ธธ์ด๋ 4๊ฐ ๋๋ค. 3์ค for ๋ฌธ์ ์ด์ฉํ์ฌ ๊ตฌํ๊ธฐ ๋ค..
0 2022.10.26 -
Algorithm ๋ถ๋ถํฉ(Partial Sum) ; ๋์ ํฉ(Prefix Sum)
๋ถ๋ถํฉ(Partial Sum) ; ๋์ ํฉ(Prefix Sum) ์ฐ์๋ ๊ตฌ๊ฐ start ๋ถํฐ end ๊น์ง์ ํฉ ๊ตฌํ๊ธฐ ์ผ์ฐจ์ ๋ฐฐ์ด a๊ฐ ์๋์ ๊ฐ์ด ์ด๊ธฐํ๋์ด ์๋ค. X 10 20 30 40 50 60 70 80 90 100 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a[10] ๋ฐฐ์ด a์์ ์ฐ์๋ ๊ตฌ๊ฐ start ๋ถํฐ end ๊น์ง์ ํฉ์ endโk=starta[k]=a[start]+a[start+1]+โฏ+a[endโ1]+a[end] ๋ก ์ ์ํ๋ค๋ฉด (startโคend), ๊ตฌ๊ฐ 5๋ถํฐ ๊ตฌ๊ฐ 9๊น์ง์ ํฉ $\displaystyle \sum_{..
0 2022.10.26 -
Algorithm ์๋ผํ ์คํ ๋ค์ค์ ์ฒด(Sieve of Erathosthenes)
์๋ผํ ์คํ ๋ค์ค์ ์ฒด(Sieve of Erathosthenes) ๊ฐ๋ ์ง๊ตฌ์ ๋๋ ๋ฅผ ์ฒ์์ผ๋ก ๊ณ์ฐํ ๊ณ ๋ ๊ทธ๋ฆฌ์ค ์ํ์ ์๋ผํ ์คํ ๋ค์ค(BC273 ~ BC192, Eratosthenes)๊ฐ ๊ธฐ์์ 200๋ ์ ๊ณ ์ํ ๋ฐฉ๋ฒ์ผ๋ก, ์๋์ ๊ฐ์ ๋ฐฉ๋ฒ์ ์ด์ฉํ์ฌ ์์๋ฅผ ๊ตฌํ๋ค. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 1์ ์์๊ฐ ์๋๋ผ๊ณ ํ์ผ๋ฏ๋ก ์ฐ์ ์ง์๋ฒ๋ฆฐ๋ค. ๋ค์์ผ๋ก ๋งจ ์ฒ์ ๋์ค๋ ์(= 2)๋ ๋ฌด์กฐ๊ฑด ์์์ด๋ค. ์๋ํ๋ฉด ์ฝ์๊ฐ 1๊ณผ ์๊ธฐ ์์ ๋ฐ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. ๊ทธ๋ฆฌ๊ณ 2์ ๋ฐฐ์๋ ์์๊ฐ ์๋๋ฏ๋ก ๋ชจ๋ ์ง์๋ฒ๋ฆฐ๋ค. ๋ค์์ผ๋ก ์ง์์ง์ง ์์ ์๋ค ์ค์์ ๊ฐ์ฅ ์์ ์(= 3)๋ฅผ ์ฐพ๋๋ค. ์ด๋ ๊ฒ ์ง์์ง์ง ์๊ณ ๋จ์ ์๋ ์์์ด๋ค. ์๋ํ๋ฉด 1์ด ์๋๋ฉด์ 3๋ณด๋ค ..
0 2022.10.25 -
Algorithm ์์ธ์ ๋ถํด(Prime/Integer Factorization)
์์ธ์ ๋ถํด(Prime/Integer Factorization) ๊ฐ๋ ํน์ ์์ฐ์๋ฅผ 1๋ณด๋ค ํฐ ์์ฐ์์ธ ์์ธ์(์์์ธ ์ธ์)๋ค๋ง์ ๊ณฑ์ผ๋ก ํํํ๋ ๊ฒ ํฉ์ฑ์๋ฅผ ์์์ ๊ณฑ์ผ๋ก ๋ํ๋ด๋ ๋ฐฉ๋ฒ ์์ธ์ ๋ถํด๋ฅผ ์ผ์์ ์ผ๋ก ๊ฒฐ์ ํ๋ ๊ณต์์ ์์ง ๋ฐ๊ฒฌ๋์ง ์์๋ค. ํ๋ ์ํธํ์์ ์์ธ์ ๋ถํด๋ ์ํธ ์ฒ๋ฆฌ๋ฅผ ํ๋๋ฐ ์ค์ํ๊ฒ ์ฌ์ฉ๋๋ค. ๋ชจ๋ ํฉ์ฑ์๋ ์์ธ์ ๋ถํด๋ ํํ๋ฅผ ๊ฐ์ง๊ณ ์๋ค. ์ฐ์ ์ ๊ธฐ๋ณธ ์ ๋ฆฌ(Fundamental Theorem of Arithmetic)๋ก ์ฆ๋ช ๋๋ค. ์๊ณ ๋ฆฌ์ฆ ๊ธฐ๋ณธ ์๊ณ ๋ฆฌ์ฆ ์์ธ์๋ 1์ด๋ผ๋ ๊ฐ์ด ์๋ 2๋ถํฐ ์์ํ๋ ๊ฒ์ด ํต์ฌ์ด๋ฉฐ, 2๋ก ๋๋์ง ๋ชปํ ๊ฒฝ์ฐ 2์์ ํ๋์ฉ ์ฆ๊ฐ์์ผ์ฃผ๋ฉด์ ๋๋์ด์ง๋์ง ์ฒดํฌํ๋ฉด ๋๋ค. void factorize(int n) { int factor = 2; // ์์ ..
0 2022.10.25 -
Algorithm ํผ๋ณด๋์น ์์ด(Fibonacci Sequence)
ํผ๋ณด๋์น ์์ด(Fibonacci Sequence) ๋ ์ค๋๋ฅด๋ ํผ๋ณด๋์น(1170 ~ 1250, Leonardo Fibonacci) ๋ ์ค๋๋ฅด๋ ํผ๋ณด๋์น(1170 ~ 1250, Leonardo Fibonacci)๋ 1170๋ ์์ ๋์์ธ ์ดํ๋ฆฌ์์ ํผ์ฌ์์ ํ์ด๋ฌ๋ค. ๊ทธ์ ์๋ฒ์ง๋ ํผ์ฌ์์ ํ์ํ ์์ธ์ผ๋ก ์ง์คํด์์ ๊ฐ๋ ฅํ ๊ถ๋ ฅ์ ๊ฐ์ง ์ฌ๋ ์ค ํ ๋ช ์ด์๋ค. ๊ทธ์ ์๋ฒ์ง๊ฐ ๋ถ๋ถ ์ํ๋ฆฌ์นด์ ํต์ ๋ฌด์ญ ๋ํ๋ก ์๋ช ๋ฐ์, ๋ถ๋ถ ์ํ๋ฆฌ์นด๋ก ์๋ค์ ๋ฐ๋ ค๊ฐ ์ต์ ์ด์ฌ๋ ์ํ์ ๋ฐฐ์ธ ์ ์๋๋ก ํ์๋ค. ํผ๋ณด๋์น๋ ์ด์งํธ, ์๋ฆฌ์, ๊ทธ๋ฆฌ์ค, ์์น ๋ฆฌ์์ ํ๋ก๋ฐฉ์ค์์ ๋ค์ํ ๊ณต๋ถ๋ฅผ ํ์๊ณ , ๊ทธ๊ณณ์์ ์ธ๋์ ๊ธฐ์๋ฒ๊ณผ ์๋ผ๋น์ ์ซ์๋ฅผ ์ฌ์ฉํ์ฌ 10์ง๋ฒ์ผ๋ก ๊ณ์ฐํ๋ ๊ฒ์ ์๊ฒ ๋์๋ค. ํผ๋ณด๋์น๋ ์ด๋ฐ ๋ค์ํ ๊ฒฝํ์ ์ด๋ ค์ ํผ์ฌ๋ก ๋..
1 2022.10.06 -
Algorithm ์ฝ์ ์ ๋ ฌ(Insertion Sort)
์ฝ์ ์ ๋ ฌ(Insertion Sort) ์ฝ์ ์ ๋ ฌ(Insertion Sort) ๋ฐฐ์ด์์ ํน์ key ๊ฐ์ด ์ ํด์ง๊ณ , ๊ทธ key ๊ฐ ์์ ์๋ ๋ฐฐ์ด์ ์์๋ค์ด ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋์ด ์์ ๋, key ๊ฐ์ด ์ฝ์ ๋ ์์น๋ฅผ ์ฐพ์์ ๊ทธ ์์น์ key ๊ฐ์ ์ฝ์ ํ๋ฉด์ ์ ๋ ฌํด ๋๊ฐ๋ ๋ฐฉ์ ๋ ๋ฒ์งธ ์์๋ฅผ key ๊ฐ์ผ๋ก ์ ํด์ ๋ ๋ฒ์งธ ์์๊ฐ ์ฝ์ ๋ ์์น๋ฅผ ์ฐพ์์ ์ฒซ ๋ฒ์งธ ์์๋ถํฐ ๋ ๋ฒ์งธ ์์๊น์ง ์ ๋ ฌ์ํค๊ณ , ๋ค์ ์ธ ๋ฒ์งธ ์์๋ฅผ key ๊ฐ์ผ๋ก ์ ํด์ ์ธ ๋ฒ์งธ ์์๊ฐ ์ฝ์ ๋ ์์น๋ฅผ ์ฐพ์์ ์ฒซ ๋ฒ์งธ ์์๋ถํฐ ์ธ ๋ฒ์งธ ์์๊น์ง ์ ๋ ฌ์ํค๊ณ ๋ค์ ๋ค ๋ฒ์งธ ์์๋ฅผ key ๊ฐ์ผ๋ก ์ ํด์ ๋ค ๋ฒ์งธ ์์๊ฐ ์ฝ์ ๋ ์์น๋ฅผ ์ฐพ์์ ์ฒซ ๋ฒ์งธ ์์๋ถํฐ ๋ค ๋ฒ์งธ ์์๊น์ง ์ ๋ ฌ์ํค๊ณ , ๋ค์ฏ ๋ฒ์งธ ์์๋ฅผ key ๊ฐ์ผ๋ก ์ ํด์ ๋ค์ฏ ๋ฒ์งธ ์์๊ฐ..
1 2022.10.06 -
Algorithm ๋ฒ๋ธ ์ ๋ ฌ(Bubble Sort)
๋ฒ๋ธ ์ ๋ ฌ(Bubble Sort) ๋ฒ๋ธ ์ ๋ ฌ(Bubble Sort) ๋ฐฐ์ด์์ ๊ฐ์ฅ ํฐ ๊ฐ์ ์ฐพ์์ ๋ง์ง๋ง์ ๋ฐฐ์น์ํค๊ณ , ๋ค์์ผ๋ก ํฐ ๊ฐ์ ์ฐพ์์ ๋์์ ๋ ๋ฒ์งธ์ ๋ฐฐ์น์ํค๊ณ , ๋ค์์ผ๋ก ํฐ ๊ฐ์ ์ฐพ์์ ๋์์ ์ธ ๋ฒ์งธ์ ๋ฐฐ์น์ํค๋ฉด์ ์ ๋ ฌํด ๋๊ฐ๋ ๋ฐฉ์ ๊ฑฐํ ๋ชจ์๊ณผ ๊ฐ์์ ๋ฒ๋ธ ์ ๋ ฌ(Bubble Sort)์ด๋ผ๊ณ ํ๋ค. ๊ตฌํ O(n2) ์ผ๋ก ๊ตฌํํ๊ธฐ #include using namespace std; #define N 5 int main() { int a[N] = { 7, 6, 9, 5, 8 }; int tmp; for (int i = 0; i a[j + 1]) { tmp = ..
0 2022.10.06 -
Algorithm ์ ํ ์ ๋ ฌ(Selection Sort)
์ ํ ์ ๋ ฌ(Selection Sort) ๋ฐ์ดํฐ์ ๊ตํ ์ค์(Swap) : ๋ ๋ณ์์ ๊ฐ์ ์๋ก ๊ตํํ๋ ์์ ๋ค์๊ณผ ๊ฐ์ด ์์ ๋ณ์(temp)๋ฅผ ์์ฑํ์ฌ ๋ฐ์ดํฐ ๊ตํ ์์ ์ ์ํํ ์ ์๋ค. temp = a; a = b; b = temp; ๋ค์๊ณผ ๊ฐ์ด ์ฝค๋ง ์ฐ์ฐ์(Comma Operator)๋ฅผ ์ฌ์ฉํ์ฌ ํ ์ค๋ก ์ฒ๋ฆฌํ ์๋ ์๋ค. temp = a, a = b, b = temp; ์ค๋ฆ์ฐจ์ ์ ๋ ฌ(Ascending Sort) ์์ ์์ด ๋์ด๋ ์๋ฃ๋ฅผ ์์ ์์์ ํฐ ์์ผ๋ก ๋ค์ ์ฌ๋ฐฐ์ดํ๋ ์์ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ(Descending Sort) ์์ ์์ด ๋์ด๋ ์๋ฃ๋ฅผ ํฐ ์์์ ์์ ์์ผ๋ก ๋ค์ ์ฌ๋ฐฐ์ดํ๋ ์์ ์ ํ ์ ๋ ฌ(Selection Sort) ๋ฐฐ์ด์์ ๊ฐ์ฅ ์์ ๊ฐ์ ์ฐพ์์ ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ์ ๋ฐฐ์น์ํค๊ณ , ๋ค..
0 2022.10.06 -
Algorithm ์ต๋(Max), ์ต์(Min), ์ต๋น(Mode)
์ต๋(Max), ์ต์(Min), ์ต๋น(Mode) ์ต๋(Max)์ ์ต์(Min) ์ฃผ์ด์ง ๋ฐฐ์ด์์ ์ต๋๊ฐ๊ณผ ์ต์๊ฐ์ ์ฐพ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋ค์๊ณผ ๊ฐ๋ค. ๋ง์ฝ ๋ฐฐ์ด์ ๊ฒ์ํด์ max/min ๋ณด๋ค ํฐ/์์ ๊ฐ์ด ์๋ค๋ฉด ์ฒ์์ ๊ฐ์ ์ผ๋ก ์ธ์ด max/min ๊ฐ์ด ์ต๋๊ฐ/์ต์๊ฐ์ด ๋๋ค. ์ต๋๊ฐ ๊ตฌํ๊ธฐ โ ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ๊ฐ์ ์ต๋๊ฐ(max)์ด๋ผ ๊ฐ์ ํ๋ค. โก ๋ฐฐ์ด์ ๊ฒ์ํด์ max ๋ณด๋ค ํฐ ๊ฐ(x)์ด ์์ผ๋ฉด max ๊ฐ์ x๋ก ๋ณ๊ฒฝํด์ค๋ค. (max = x) โข ๊ฒฐ๊ตญ ๋ง์ง๋ง์ ์ต๋๊ฐ์ด max ๋ณ์์ ๋จ๊ฒ ๋๋ค. ์ต์๊ฐ ๊ตฌํ๊ธฐ โ ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ๊ฐ์ ์ต์๊ฐ(min)์ด๋ผ ๊ฐ์ ํ๋ค. โก ๋ฐฐ์ด์ ๊ฒ์ํด์ min๋ณด๋ค ์์ ๊ฐ(y)์ด ์์ผ๋ฉด min ๊ฐ์ y๋ก ๋ณ๊ฒฝํด์ค๋ค. (min = y) โข ๊ฒฐ๊ตญ ๋ง์ง๋ง์ ์ต์๊ฐ์ด min ๋ณ์์ ๋จ๊ฒ..
0 2022.10.06 -
Algorithm ์ฝ๋ผ์ธ ์ถ์ธก(Collatz Conjecture) ; ์ฐ๋ฐ์(Hailstone Sequence), 3N + 1 Problem
์ฝ๋ผ์ธ ์ถ์ธก(Collatz Conjecture) ๊ฐ๋ 1937๋ ์ ์ฒ์์ผ๋ก ์ด ์ถ์ธก์ ์ ๊ธฐํ ๋ ์ผ์ ์ํ์ ๋กํ๋ฅด ์ฝ๋ผ์ธ (1910 ~ 1990, Lorthar Collatz)์ ์ด๋ฆ์ ๋ด ๋ฒ์น ์ฒ์ ์์์ ์์์ ์์ ์ ์ N ์์ ์์ํ๋ค. ๋ง์ฝ N ์ด ์ง์์ด๋ฉด, N ์ 2๋ก ๋๋๋ค. ๋ง์ฝ N ์ด ํ์์ด๋ฉด, N ์ 3์ ๊ณฑํ ํ 1์ ๋ํ๋ค. ์์ ๊ฐ์ ๊ณผ์ ์ 1์ด ๋ ๋๊น์ง ๋ฐ๋ณตํ๋ค. ์) 8 โ 4 โ 2 โ 1, 3 โ 10 โ 5 โ 16 โ 8 โ 4 โ 2 โ 1 ์ด๋ฌํ ์๋ค์ ๋ง์น ์ฐ๋ฐ์ด ๊ตฌ๋ฆ ์์์ ์ค๋ฅด๋ด๋ฆฌ๋ฉฐ ์๋ผ๋ค๊ฐ ์ง์์ผ๋ก ๋จ์ด์ง๋ ๊ฒ๊ณผ ๋น์ทํ๋ค ํ์ฌ "์ฐ๋ฐ์(Hailstone Sequence)" ๋๋ "3N + 1 Problem" ์ด๋ผ๊ณ ๋ถ๋ฆฌ๊ธฐ๋ ํ๋ค. ์์ง๊น์ง ์ฆ..
0 2022.09.01 -
Algorithm ์์(Prime Number) ; ์๋ฅ์ด ์์(Twin Primes), ๋ฉ๋ฅด์ผ ์์(Mersenne Primes), ๊ณจ๋๋ฐํ์ ์ถ์ธก(Goldbach's Conjecture)
์์(Prime Number) ์ฝ์์ ๊ฐ์๋ฅผ ์ด์ฉํ ์์์ ํ๋ณ 1๋ณด๋ค ํฐ ์์ฐ์ ์ค์์ 1๊ณผ ์๊ธฐ ์์ ์ด์ธ์๋ ์ฝ์๋ฅผ ๊ฐ์ง์ง ์๋ ์, ์ฆ ์ฝ์์ ๊ฐ์๊ฐ 2๊ฐ์ธ ์์ฐ์๋ฅผ ์์(Prime Number)๋ผ๊ณ ํ๋ค. 2์ ์ฝ์ : 1, 2 3์ ์ฝ์ : 1, 3 4์ ์ฝ์ : 1, 2, 4 5์ ์ฝ์ : 1, 5 6์ ์ฝ์ : 1, 2, 3, 6 7์ ์ฝ์ : 1, 7 2, 3, 5, 7, ... ๋ฑ์ ์ฝ์์ ๊ฐ์๊ฐ 2๊ฐ ์ด๋ฏ๋ก ์์์ด๋ค. ์์ #include using namespace std; int main() { int cnt; for (int i = 2; i
0 2022.09.01 -
Algorithm ํฐ๋ฆฐ๋๋กฌ(Palindrome)
ํฐ๋ฆฐ๋๋กฌ(Palindrome) ํฐ๋ฆฐ๋๋กฌ(Palindrome) ๋ณดํต ๋ฑ๋ง ์ฌ์ด์ ์๋ ๋์ด์ฐ๊ธฐ๋ ๋ฌธ์ฅ ๋ถํธ๋ ๋ฌด์ํ๊ณ , ์์ผ๋ก ์ฝ์ผ๋ ๊ฑฐ๊พธ๋ก ์ฝ์ผ๋ ๊ฐ์ ๋ฌธ์ฅ ๋๋ ๋ฑ๋ง์ ํ๋ฌธ(ๅๆ) ๋๋ ํฐ๋ฆฐ๋๋กฌ(Palindrome) ์ด๋ผ๊ณ ํ๋ค. ์) "์์ฃผ ๋ง ๋ณ๋ง ์ฃผ์", "์ฌ๋ณด ์๊ฒฝ ์๋ณด์ฌ" ์ํ์์๋ 111, 12321๊ณผ ๊ฐ์ด ๋๋ฐ๋ก ์ฝ์ผ๋ ๊ฑฐ๊พธ๋ก ์ฝ์ผ๋ ๊ฐ์ ์๋ฅผ ํฐ๋ฆฐ๋๋กฌ ์(Palindrome Number) ๋๋ ๋์นญ์๋ผ๊ณ ํ๋ค. ์ซ์ ๋ค์ง๊ธฐ ์ซ์ k = 123, r = 0 ์ผ๋ก ์ด๊ธฐํ๋์ด ์๋ค๊ณ ํ ๋, ๋ค์์ ์ํ๋ฌธ์ ์๋ฃํ๋ฉด k์ ๊ฐ์ 0์ด ๋๊ณ r์ ๊ฐ์ k์ ๊ฐ์ด ๊ฑฐ๊พธ๋ก ๋ค์ง์ด์ง 321์ด ๋๋ค. int k = 123; int r = 0; ์ซ์ ๋ค์ง๊ธฐ ์๊ณ ๋ฆฌ์ฆ while (k != 0) { p = k..
0 2022.09.01 -
Algorithm ์์ ์ ๊ณฑ์(Perfect Square Number, ์ ๊ณฑ์, ์ ์ฌ๊ฐ์)
์์ ์ ๊ณฑ์(Perfect Square Number, ์ ๊ณฑ์, ์ ์ฌ๊ฐ์) ์ ์ฌ๊ฐ์(Square Number) ์ด๋ค ์์ฐ์์ ์ ๊ณฑ์ด ๋๋ 12,22,32,42๊ณผ ๊ฐ์ ์๋ฅผ ์์ ์ ๊ณฑ์(Perfect Square Number) ๋๋ ์ ๊ณฑ์(Square Number) ๋๋ ์ ์ฌ๊ฐ์๋ผ๊ณ ํ๋ค. 1 = 1ยฒ 1 + 3 = 2ยฒ 1 + 3 + 5 = 3ยฒ 1 + 3 + 5 + 7 = 4ยฒ 1 + 3 + 5 + 7 + 9 = 5ยฒ ์์์์ ๊ฐ์ด 1๋ถํฐ ์ฐ์๋ ํ์์ ํฉ์ ์ธ์ ๋ ์์ ์ ๊ณฑ์์์ ์ ์ ์๋ค. ์์ ์ ๊ณฑ์ ํ๋ณํ๊ธฐ โ ์ฝ์์ ๊ฐ์๋ฅผ ์ด์ฉํ ์์ ์ ๊ณฑ์ ํ๋ณ ์์ ์ ๊ณฑ์๋ ์ฝ์์ ๊ฐ์๊ฐ ์ธ์ ๋ ํ์๊ฐ์ด๋ฏ๋ก ์ฝ์์ ๊ฐ์๋ฅผ ํ์ธํ์ฌ ์์ ์ ๊ณฑ์์ธ์ง ํ๋ณํ ์ ์๋ค. ์์ 1๋ถํฐ 100๊น์ง์..
0 2022.08.31 -
Algorithm ํฉํ ๋ฆฌ์ผ(Factorial)
ํฉํ ๋ฆฌ์ผ(Factorial) ํฉํ ๋ฆฌ์ผ(Factorial) 1๋ถํฐ N๊น์ง ๋ชจ๋ ๊ณฑํ ์๋ฅผ N ํฉํ ๋ฆฌ์ผ(Factorial)์ด๋ผ ๋ถ๋ฅด๋ฉฐ, ๊ธฐํธ๋ก๋ N!๋ก ๋ํ๋ธ๋ค. N! = 1 x 2 x 3 x ... x N ๊ณฑ์ ์ฐ์ฐ์ ํ ๋์ ์ด๊น๊ฐ์ ์ธ์ ๋ 1์ด์ด์ผ ํ๋ค. ์ด๊น๊ฐ์ด 0์ผ ๊ฒฝ์ฐ, ์ด๋ค ์๋ฅผ ๊ณฑํด๋ ํญ์ 0์ด ๋๋ค. ์) 5! = 1 ร 2 ร 3 ร 4 ร 5 = 120 ์์ 5! ๊ตฌํ๊ธฐ #include using namespace std; int main() { int fact; fact = 1; // ์ด๊น๊ฐ์ ํญ์ 1์ด์ด์ผ ํ๋ค. for (int i = 1; i
0 2022.08.31 -
Algorithm ์์ ์(Perfect Number), ๋ถ์กฑ์(Deficient Number), ๊ณผ์์(Abundant Number)
์์ ์(Perfect Number), ๋ถ์กฑ์(Deficient Number), ๊ณผ์์(Abundant Number) ์์ ์(Perfect Number) ๊ทธ ์ ์์ ์ ์ ์ธํ ๋ชจ๋ ์ฝ์์ ํฉ์ด ๊ทธ ์ ์์ ๊ณผ ๊ฐ์ ์๋ฅผ ์์ ์(Perfect Number)๋ผ๊ณ ํ๋ค. ์) 6์ ์ฝ์๋ {1, 2, 3, 6} ์ด๊ณ , ๊ทธ ์ ์์ ์ ์ ์ธํ 1 + 2 + 3์ ํฉ์ 6๊ณผ ๊ฐ์ผ๋ฏ๋ก 6์ ์์ ์์ด๋ค. ๋ถ์กฑ์(Deficient Number) ๊ทธ ์ ์์ ์ ์ ์ธํ ๋ชจ๋ ์ฝ์์ ํฉ์ด ๊ทธ ์ ์์ ๋ณด๋ค ์์ ์๋ฅผ ๋ถ์กฑ์(Deficient Number)๋ผ๊ณ ํ๋ค. ์) 8์ ์ฝ์๋ {1, 2, 4, 8} ์ด๊ณ , ๊ทธ ์ ์์ ์ ์ ์ธํ 1 + 2 + 4์ ํฉ์ 7๊ณผ ๊ฐ์ผ๋ฏ๋ก 8์ ๋ถ์กฑ์์ด๋ค. ๊ณผ์์(Abundant Number) ๊ทธ..
0 2022.08.31 -
Algorithm ๋ฐฐ์(Multiple)์ ์ฝ์(Divisor)
๋ฐฐ์(Multiple)์ ์ฝ์(Divisor) ๋ฐฐ์(Multiple) ์ด๋ค ์์๋ค 1๋ฐฐ, 2๋ฐฐ, 3๋ฐฐ, 4๋ฐฐ, ... ํ ์๋ค์ ๊ทธ ์์ ๋ฐฐ์(Multiple)๋ผ๊ณ ํ๋ค. ์) {3, 6, 9, ...} ๋ 3์ ๋ฐฐ์์ด๋ค. ์์ 1๋ถํฐ 100 ์ฌ์ด์ 3์ ๋ฐฐ์ ์ถ๋ ฅํ๊ธฐ #include using namespace std; int main() { for (int i = 1; i
0 2022.08.31 -
Algorithm ๊ฐ์ฐ์ค ๊ณ์ฐ๋ฒ(Gaussian Calculation)
๊ฐ์ฐ์ค ๊ณ์ฐ๋ฒ(Gaussian Calculation) ๊ฐ์ฐ์ค(1777 ~ 1885, Carl Friedrich Gauss) ๊ฐ์ฐ์ค(1777 ~ 1885, Carl Friedrich Gauss)์ ์ ์๋ ๋ทํธ๋๋ ์์ ์๊ฐ์ ์ ์ ์ด ์๊ฐ์ผ๋ก ํ์๋ค์๊ฒ 1๋ถํฐ 100๊น์ง ๋ํ๋ ๋ฌธ์ ๋ฅผ ๋๋ค. ๊ฐ์ฐ์ค๋ ์์๊ฐ์ 5050 ์ด๋ผ๋ ์ ๋ต์ ์์๋ด์๋ค. ๊ฐ์ฐ์ค์ ์ฒ์ฌ์ฑ์ ์์๋ณธ ๋ทํธ๋๋ ๊ทธ์๊ฒ ๊ณ ๋ฑํ๊ต ์ํ ๊ต๊ณผ์๋ฅผ ์ ๋ฌผํ๋ค๊ณ ํ๋ค. ๋ ์ผ์ ์ํ์ ๊ฐ์ฐ์ค๋ ์๋ฅดํค๋ฉ๋ฐ์ค, ๋ดํด๊ณผ ํจ๊ป ์ํ์ ์ญ์ฌ์ด ๊ฐ์ฅ ์๋ํ ์ธ ๋ช ์ ์ํ์ ์ค ํ ๋ช ์ด๋ค. ๊ฐ์ฐ์ค ๊ณ์ฐ๋ฒ ์ฐ์๋ ์ ๋๋ ๊ท์น์ ์ผ๋ก ๋์ด๋์ด ์๋ ์์ด ๋ฑ์ ํฉ์ ์ฝ๊ฒ ๊ณ์ฐํ๊ธฐ ์ํด์ ์ฌ์ฉํ๋ ๊ณ์ฐ๋ฒ ์ผ๋ฐํํ๋ฉด ๋ค์๊ณผ ๊ฐ๋ค. ์ฒ์ ๊ฐ๋ถํฐ ๋ง์ง๋ง ๊ฐ๊น์ง์ ํฉ = (์ฒ์..
0 2022.08.31 -
Algorithm ์๊ณ ๋ฆฌ์ฆ์ด๋?
์๊ณ ๋ฆฌ์ฆ์ด๋? ์๊ณ ๋ฆฌ์ฆ์ ๊ฐ๋ ์๊ณ ๋ฆฌ์ฆ(algorithm) : ์ฃผ์ด์ง ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ์ ์ฐจ(Procedure) ๊ฐ ๋จ๊ณ๋ ๊ธฐ๋ณธ์ ์ธ ์ฐ์ฐ(Operation) ํ๋๋ก ์ด๋ฃจ์ด์ ธ ์์ ์๋ ์๊ณ , ํน์ ๋ค๋ฅธ ๋ถ๋ถ ๋ฌธ์ (Subproblem)์ ๋ํ ์๊ณ ๋ฆฌ์ฆ์ผ ์๋ ์์ง๋ง ์ถฉ๋ถํ ๊ตฌ์ฒด์ ์ด์ด์ผ ํ๋ค. ์๊ณ ๋ฆฌ์ฆ์ ์กฐ๊ฑด ์ผ๋ฐ์ ์ผ๋ก ์๊ณ ๋ฆฌ์ฆ์ ๋ค์์ ๋ ์กฐ๊ฑด์ ๋ฐ๋์ ๋ง์กฑํด์ผ ํ๋ค. ์ข ๋ฃ(termination) : ๋ชจ๋ ๊ฐ๋ฅํ ์ ๋ ฅ ์ฌ๋ก์ ๋ํ์ฌ ๋ฐ๋์ ๋๋๋ค. ์ ํ์ฑ(correctness) : ๋ชจ๋ ๊ฐ๋ฅํ ์ ๋ ฅ ์ฌ๋ก์ ๋ํ์ฌ ์ณ์ ๋ต์ ์ถ๋ ฅํ๋ค. ์ข์ ์๊ณ ๋ฆฌ์ฆ ์์(Resource)์ ์ ๊ฒ ์ฐ๋ ์๊ณ ๋ฆฌ์ฆ์ด ์ข์ ์๊ณ ๋ฆฌ์ฆ์ด๋ผ๊ณ ํ ์ ์๋ค. ๊ฐ๋ฅํ ์ ๋ ฅ์ ๋ํ์ฌ ํญ์ ์ข ๋ฃํ๊ณ ์ณ์ ๋ต์ ์ถ๋ ฅํ๋ฉด ์๊ณ ๋ฆฌ์ฆ์ด ๋์ง๋ง, ์คํ์..
0 2022.06.24