Algorithm
ํ๋ก๊ทธ๋๋ฐ = ์๋ฃ๊ตฌ์กฐ + ์๊ณ ๋ฆฌ์ฆ
์ปดํจํฐ๊ฐ ํจ์จ์ ์ผ๋ก ๋ฌธ์ ๋ฅผ ์ฒ๋ฆฌํ๊ธฐ ์ํด์๋ ๋ฌธ์ ๋ฅผ ์ ์ํ๊ณ ๋ถ์ํ์ฌ ์ต์ ์ ํ๋ก๊ทธ๋จ์ ์์ฑํด์ผํ๋ค.
์๋ฃ(Data) : ํ๋ก๊ทธ๋จ์ ์ฒ๋ฆฌ ๋์์ด ๋๋ ๊ฐ๋ค
์๋ฃํ(Data Type) : ์ฒ๋ฆฌํ ์๋ฃ์ ์งํฉ๊ณผ ์๋ฃ์ ๋ํด ์ ์ฉํ ์ ์๋ ์ฐ์ฐ์์ ์งํฉ
์ฐ์ฐ(operation) : ์ด๋ค ์ผ์ ์ฒ๋ฆฌํ๋ ๊ณผ์
์๋ฃ๊ตฌ์กฐ(Data Structure) : ์๋ฃ๋ฅผ ํจ์จ์ ์ผ๋ก ํํํ๊ณ ์ ์ฅํ๊ณ ์ฒ๋ฆฌํ ์ ์๋๋ก ์ ๋ฆฌํ๋ ๊ฒ
์คํ(Stack), ํ(Queue)
Array List, Node List, Sequence
Map, Dictionary
Priority Queue
Tree, Binary Tree, Heap, Search Tree
Graph
์๋ฃ์ ์ถ์ํ(Data Abstraction)
ํฌ๊ณ ๋ณต์กํ๊ณ ์ด๋ ค์ด ๋ฌธ์ ๋ฅผ ์ฒ๋ฆฌํ ๋
ํฐ ๋ฌธ์ ๋ ์๊ฒ ๋๋์ด ๋จ์ํ ์๊ฐํ๊ธฐ(๋จ์ํ)
ํต์ฌ์ ์ธ ๊ฒ์ ์ง์คํ๊ธฐ(์ถ์ํ)
์ค์์ ๋ณด๋ถํฐ ๊ฐ์กฐํ๊ธฐ(์ ๋ณด์๋)
์ถ์ ๋ฐ์ดํฐ ํ์
(ADT : Abstract Data Type)
์๋ฃ์ ์ฐ์ฐ์์ ํน์ฑ์ ๋ ผ๋ฆฌ์ ์ผ๋ก ์ถ์ํํ์ฌ ์ ์ํ ์๋ฃํ
์ถ์ํ : "๋ฌด์(what)"์ธ๊ฐ๋ฅผ ๋ ผ๋ฆฌ์ ์ผ๋ก ์ ์ : ์๊ณ ๋ฆฌ์ฆ ์ ์
๊ตฌ์ฒดํ : "์ด๋ป๊ฒ(how)"ํ ๊ฒ์ธ๊ฐ๋ฅผ ์ค์ ์ ์ผ๋ก ํํ : ํ๋ก๊ทธ๋จ ๊ตฌํ
์๊ณ ๋ฆฌ์ฆ(Algorithm)
์ฃผ์ด์ง ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํ ๋จ๊ณ์ ์ธ ์ ์ฐจ์ด๋ค.
์ด ์ ์ฐจ์๋ ์ ๋ ฅ๊ฐ๊ณผ ์ถ๋ ฅ๊ฐ์ด ์กด์ฌํด์ผํ๋ฉฐ, ์ ํํ ๋จ๊ณ๋ฅผ ๊ฑฐ์ณ์ ๋ฐ๋์ ์ข ๋ฃ๋์ด์ผ ํ๋ค.
์กฐ๊ฑด
์ ๋ ฅ : 0๊ฐ ์ด์์ ์ ๋ ฅ ์กด์ฌ
์ถ๋ ฅ : 1๊ฐ ์ด์์ ์ถ๋ ฅ ์กด์ฌ
๋ช ๋ฐฑ์ฑ : ๊ฐ ๋ช ๋ น์ด์ ์๋ฏธ๋ ๋ชจํธํ์ง ์๊ณ ๋ช ํํด์ผํจ
์ ํ์ฑ : ํ์ ๋ ์์ ๋จ๊ณ ํ์๋ ๋ฐ๋์ ์ข ๋ฃํ๋ค.
์ ํจ์ฑ : ๊ฐ ๋ช ๋ น์ด๋ค์ ์คํ ๊ฐ๋ฅํ ์ฐ์ฐ์ด์ด์ผํ๋ค.
ํํ๋ฐฉ๋ฒ
์๊ณ ๋ฆฌ์ฆ์ ์ฃผ๋ก ์์ฐ์ด, ์์ฌ์ฝ๋, ํ๋ก๊ทธ๋๋ฐ์ธ์ด ๋ฑ์ ๋ฐฉ๋ฒ์ผ๋ก ๊ธฐ์ ํ ์ ์๋ค.
์์ฐ์ด
์์ฌ์ฝ๋(shudo code)
ํ๋ก๊ทธ๋๋ฐ ์ธ์ด
์์๋(Flow chart)๋ฅผ ์ด์ฉํ ๋์ํ ํํ
๊ณ์ฐ ๋ฌธ์
์ํ์ ์ผ๋ก ๊ณ์ฐ ๊ฐ๋ฅํ๋ฉฐ, ์ปดํจํฐ๋ฅผ ์ด์ฉํด ํ ์ ์๋ ๋ชจ๋ ๋ฌธ์ ๋ค์ ์๋ฏธํ๋ค.
๊ฒฐ์ ๋ฌธ์ (decision problem)
ํ์ ๋ฌธ์ (search problem)
์นด์ดํ ๋ฌธ์ (counting problem)
์ต์ ํ ๋ฌธ์ (optimization problem)
ํจ์ํ ๋ฌธ์ (function problem)
๊ฒฐ์ ๋ฌธ์
๊ณ์ฐ ๋ฌธ์ ๋ค ์ค ๊ทธ ๊ฒฐ๊ณผ๋ฅผ 'YES' or 'NO'๋ก ๋ตํ ์ ์๋ ๋ฌธ์ ๋ฅผ ์๋ฏธํ๋ค.
์ต์ ํ ๋ฌธ์
๊ณ์ฐ๊ฒฐ๊ณผ ์ป์ ํ๋ณด ํด๋ค ์ค ๊ฐ์ฅ ์ ์ ํ ํด๋ฅผ ์ฐพ๋ ํํ์ ๋ฌธ์ ๋ฅผ ๋งํ๋ค.
์ฑ๋ฅ๋ถ์
ํ๊ฐ๊ธฐ์ค
์ ํ์ฑ : ์ฌ๋ฐ๋ฅธ ์๋ฃ ์ ๋ ฅ ์ ์ ํํ ์๊ฐ ๋ด์ ์ฌ๋ฐ๋ฅธ ๊ฒฐ๊ณผ ์ถ๋ ฅ ์ฌ๋ถ
๋ช ํ์ฑ : ์๊ณ ๋ฆฌ์ฆ์ด ์ผ๋ง๋ ์ดํดํ๊ธฐ ์ฝ๊ณ ๋ช ํํ๊ฒ ์์ฑ๋์๋๊ฐ
์ํ๋ : ์ผ๋ฐ์ ์ธ ์ฐ์ฐ ์ ์ธ, ์๊ณ ๋ฆฌ์ฆ ํน์ฑ์ ๋ํ๋ด๋ ์ค์ ์ฐ์ฐ ๋ชจ๋ ๋ถ์
์คํ์๊ฐ, ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ => ์ธก์ ๊ฐ๋ฅ
์ต์ ์ฑ : ๊ฐ์ฅ์ค์
์๋ฃ๊ตฌ์กฐ๋ก ์๊ณ ๋ฆฌ์ฆ์ ์๋ฃํ๋๋ฐ ์ผ๋ง๋ ๋ง์ ์๊ฐ๊ณผ ๊ณต๊ฐ์ด ํ์ํ์ง์ ๋ฐ๋ผ ์ด ์๋ฃ๊ตฌ์กฐ๊ฐ ์ข์์ง ๋์์ง ํ๊ฐํ ์ ์๋ค.
์ํ์๊ฐ ์ธก์
์คํ์๊ฐ์ด ์งง์ผ๋ฉด์ ๋ฉ๋ชจ๋ฆฌ ์์์ ๋ ์ฌ์ฉํ๋ ๊ฒ์ด ํจ์จ์
์ผ๋ฐ์ ์ผ๋ก ์คํ์๊ฐ์ด ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ๋ณด๋ค ๋ ์ค์์
์ํ์๊ฐ์ ์ธก์ ํ๋ ์ ํ์ ์ธ ํ๋ก๊ทธ๋จ์ด๋ค. ํ์ง๋ง ์ํํธ์จ์ด ํ๊ฒฝ์ ๋ฐ๋ฅธ ์คํ์๋์ ์ฐจ์ด์ ๋ฐ์ดํฐ์ ๋ฐ๋ฅธ ์ ํ ๋ค๋ฅธ ๊ฒฐ๊ณผ ๋ฑ๋ฑ์ ๋ฌธ์ ์ ๋ ์๋ค.
๋ณต์ก๋ ๋ถ์
์๊ณ ๋ฆฌ์ฆ ํจ์จ์ฑ์ ๊ณ์ฐ๋์ผ๋ก ํํํ ๊ฒ์ด๋ฉฐ, ๊ณ์ฐ๋์ ์ ๋ ฅํฌ๊ธฐ n์ ๋ํ ์คํ์๊ฐ์ ๋ํ๋ธ๋ค.
์ด๋ ์๊ณ ๋ฆฌ์ฆ์ด ๊ฐ์ฅ ๋น ๋ฅธ๊ฐ, ๋น์ฉ์ด ์ ๊ฒ ๋๋๊ฐ, ์ต์ ์ด๋ผ ๋ณผ ์ ์๋๊ฐ
์คํ๊ณผ ๊ด๊ณ์์ด ํจ์จ์ฑ์ ํ๊ฐํ์
์ง์ ๊ตฌํํ์ง ์๊ณ ์๋ ๋๋ต์ ์ธ ์ํ ์๊ฐ์ ๋ถ์ํ๋ ๋ฐฉ๋ฒ
์๊ฐ ๋ณต์ก๋(time complexity) : ์๊ณ ๋ฆฌ์ฆ์ ์ํ ์๊ฐ ๋ถ์
์๊ณ ๋ฆฌ์ฆ์ ์ด๋ฃจ๊ณ ์๋ ๊ธฐ๋ณธ ์ฐ์ฐ๋ค์ด ๋ช ๋ฒ์ด๋ ์ํ๋๋์ง๋ฅผ ์ซ์๋ก ํ์(์ฐ์ , ๋์ , ๋น๊ต, ์ด๋ ๋ฑ์ ๊ธฐ๋ณธ์ ์ธ ์ฐ์ฐ)
์ ๋ ฅ์ ๊ฐ์๊ฐ n์ผ ๋, ์ฐ์ฐ์ ์คํํ์๋ n์ ๋ฐ๋ผ ๋ณํ๋ค
์๊ฐ๋ณต์ก๋ T(n) โ ์ ๋ ฅ์ ๊ฐ์ n์ ๋ํ ํจ์
์ค์ ์คํ์๊ฐ ๋ณด๋ค๋ ๋ช ๋ น๋ฌธ์ ์คํ ๋น๋์์ ๋ฐ๋ผ ๊ณ์ฐ
๊ณต๊ฐ ๋ณต์ก๋(space complexity) : ์๊ณ ๋ฆฌ์ฆ ์ํ์ ํ์๋กํ๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ ๋ถ์
ํ์ด์ฌ ๊ณต๊ฐ ๋ณต์ก๋ ์ฃผ์ : ํ์ด์ฌ์ ๋ค๋ฅธ ์ธ์ด์ ๋นํด์ ๊ตฌํ์์ ๋ณต์กํจ์ด ์ ์ ํธ์ด์ง๋ง ๋ฐ์ดํฐ ์ฒ๋ฆฌ๋์ด ๋ง์ ๋๋ ๊ผญ ๋ฉ๋ชจ๋ฆฌ ์ ํ์ ๊ณ ๋ คํ๋๋ก ํด์ผํ๋ค. ๋ฆฌ์คํธ๋ฅผ ์ฌ๋ฌ๊ฐ ์ ์ธํ๊ณ , ๊ทธ์ค์์ ํฌ๊ธฐ๊ฐ 1,000๋ง ์ด์์ธ ๋ฆฌ์คํธ๊ฐ ์๋ ๊ฒฝ์ฐ์๋ ๋ฉ๋ชจ๋ฆฌ ์ ํ์ ๊ณ ๋ คํด์ผํ๋ค.
int ์๋ฃํ ๋ฐ์ดํฐ์ ๊ฐ์์ ๋ฐ๋ฅธ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋
๋ฐ์ดํฐ์ ๊ฐ์
๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋
1,000
์ฝ 4KB
1,000,000
์ฝ 4MB
1,000,000,000
์ฝ 40MB
์ฑ๋ฅ ๋ถ์ ํ๊ธฐ๋ฒ
๋น ์ค(O)ํ๊ธฐ๋ฒ : ์ฐ์ฐ์ ํ์๋ฅผ ๋๋ต์ (์ ๊ทผ์ )์ผ๋ก ํ๊ธฐํ์ฌ ํจ์์ ์ํ์ ํ์ํ๊ธฐ ์ํ ๋ฐฉ๋ฒ
๊ถ๊ทน์ ์ผ๋ก ๋คํญ์์ ์ต๊ณ ์ฐจํญ์ ์ฐจ์๋ง ์ฌ์ฉํ๋ค.
์ฌ์ค์ ์ง์ํ์ด๋ ํฉํ ๋ฆฌ์ผ์ ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋ฉด ์ฌ์ฉํ๋ ๊ฒ์ด ๋ฌด์๋ฏธํ๋ค.
๋น ์ค๋ฉ๊ฐ : ํจ์์ ํํ์ ํ์ํ๊ธฐ ์ํ ๋ฐฉ๋ฒ
๋น ์ธํ : ํจ์์ ํํ์ธ ๋์์ ์ํ์ ํ์
์ต์ , ํ๊ท , ์ต์
์ ๊ฒฝ์ฐ
์ต์ ์ ๊ฒฝ์ฐ : ์ํ ์๊ฐ์ด ๊ฐ์ฅ ๋น ๋ฅธ ๊ฒฝ์ฐ
์ฐพ๊ณ ์ ํ๋ ์ซ์๊ฐ ๋งจ ์์ ์์(O(1))
์ต์ ์ ๊ฒฝ์ฐ : ์ํ ์๊ฐ์ด ๊ฐ์ฅ ๋ฆ์ ๊ฒฝ์ฐ
์ฐพ๊ณ ์ ํ๋ ์ซ์๊ฐ ๋งจ ๋ค์ ์๋ ๊ฒฝ์ฐ(O(n))
ํ๊ท ์ ๊ฒฝ์ฐ : ์ํ์๊ฐ์ด ํ๊ท ์ ์ธ ๊ฒฝ์ฐ
๊ฐ ์์๋ค์ด ๊ท ์ผํ๊ฒ ํ์ (O(n))
ํ๋ก๊ทธ๋๋ฐ ๋ํ๋ฅผ ์ํ ์ฌ์ฏ ๋จ๊ณ ๋ฌธ์ ํด๊ฒฐ ์๊ณ ๋ฆฌ์ฆ
๋ฌธ์ ๋ฅผ ์ฝ๊ณ ์ดํดํ๋ค.
์ฌ์ ์์ ์ถ์ํ ๋ฌธ์ ๋ฅผ ์ต์ํ ์ฉ์ด๋ก ์ฌ์ ์ํ๋ค.
์ด๋ป๊ฒ ํด๊ฒฐํ ์ง ๊ณํ์ ์ธ์ด๋ค.
๊ณํ์ ๊ฒ์ฆํ๋ค.
ํ๋ก๊ทธ๋จ์ผ๋ก ๊ตฌํํ๋ค.
์ด๋ป๊ฒ ํ์๋์ง ๋์๋ณด๊ณ , ๊ฐ์ ํ ๋ฐฉ๋ฒ์ด ์๋์ง ์ฐพ์๋ณธ๋ค.
์ค์ต
C++
์
๋ ฅ์ ๋ชจ๋ฅด๋ ๊ฒฝ์ฐ
์ ๋ ฅ์ด ๋ช ๊ฐ์ธ์ง ์ฃผ์ด์ง์ง ์์ ๊ฒฝ์ฐ๊ฐ ์๋ค.
์ด๋ ๊ฒ ์ ๋ ฅ์ EOF๊น์ง ๋ฐ์ผ๋ฉด ๋๋ค.
ํ ์ค ์
๋ ฅ๋ฐ๊ธฐ
while์ ์ด์ฉํด์ ์ ๋ ฅ์ ๋ฐ์ ๊ณต๋ฐฑ๊น์ง ๊ทธ๋๋ก ์ถ๋ ฅํ ์ ์๋ค.
์ซ์์
๋ ฅ๋ฐ๊ธฐ
%d
์ฌ์ด์ ์ซ์๋ฅผ ๋ฃ์ผ๋ฉด ๊ทธ ๊ธธ์ด๋งํผ ์
๋ ฅ์ ๋ฐ๋๋ค.
typedef
C์ธ์ด์์ ์ฌ์ฉ์ ์ ์ ๋ฐ์ดํฐ ํ์ ์ ๋ง๋๋ ๊ฒฝ์ฐ์ ์ฐ์ด๋ ํค์๋์ด๋ค. ํ์ ์ ์๋กญ๊ฒ ์ ์ํ๋ ๊ฒ์ด ์๋, ์ด๋ฏธ ์ ์๋์ด ์๋ ํ์ ์ ๋ค๋ฅธ ํ์ ์ ๋ถ์ฌํ๋ ๊ฒ์ด๋ค.
python
์
๋ ฅ๋ฐ๊ธฐ
ํ์ด์ฌ์ input()
์ผ๋ก ๊ฐ๋จํ๊ฒ ์
๋ ฅ ๋ฐ์ ์ ์๋ค. ์ด๋ ๋ฐ๋ ๊ฐ์ด int์ฌ์ผํ๋ค๋ฉด,
๋ฐ๋ ๊ฐ์ ๋ฆฌ์คํธ๋ก ๋งคํํด์ผํ๋ค๋ฉด
๋ค์๊ณผ ๊ฐ์ด ์ ๋ ฅ๊ฐ์ ๋ค์ํ๊ฒ ๋ฐ์ ์ฌ ์ ์๋ค.
๋น ๋ฅด๊ฒ ์
๋ ฅ๋ฐ๊ธฐ
์
๋ ฅ ๋ฐ์ดํฐ์ ์๊ฐ ๋ง์ ๋ฌธ์ ์ input()
ํซ๋ฌด๋ฅผ ์ฌ์ฉํ๋ฉด, ๋์ ์๋๊ฐ ๋๋ ค ์๊ฐ ์ด๊ณผ๋ก ์ค๋ต ํ์ ์ ๋ฐ์ ์ ์๋ค.
๋ค์๊ณผ ๊ฐ์ด sys
๋ผ์ด๋ธ๋ฌ๋ฆฌ์ readline()
์ ์ฌ์ฉํ๋ ๊ฒ์ ๊ถ์ฅํ๋ค.
์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ํ์ด ์ฌ์ดํธ
https://codeup.kr/ : ๋์ด๋๊ฐ ๋ฎ์ ๊ธฐ๋ณธ๋ฌธ์ ํ์ด
Last updated