์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
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 |
- ๋ฐ์ดํฐ๋ฒ ์ด์ค
- ์นํ์ด์ง๋ง๋ค๊ธฐ
- ์ค๋ผํด
- K๋ฐฐํฐ๋ฆฌ๋ ๋ณผ๋ฃจ์
- ๋ฐ์ํ
- ํ๋ก๊ทธ๋๋ฐ
- K๋ฐฐํฐ๋ฆฌ
- css
- Python
- ์ค๋ธ์
- ํ์ด์ฌ
- JavaScript
- ๋ฆฌ์กํธ
- html
- ์ฑ
- ์นํผ๋ธ๋ฆฌ์ฑ
- ์ฝ๋ฉ
- ํฐ์คํ ๋ฆฌ์ฑ๋ฆฐ์ง
- ์ํ
- database
- ๋ ์
- ์๋ฐ์คํฌ๋ฆฝํธ
- ComputerScience
- ๊ฐ๋ฐ
- Java
- ๋ง์ผ๋ด๊ฐ์ธ์์๋ค์์ฐ๋ค๋ฉด
- ๋ผํ๋ผ์ค์๋ง๋
- ์๋ฐ
- ์ปดํจํฐ๊ณผํ
- ๊น๋ฏธ๊ฒฝ์๋งํ์์
- Today
- Total
JiYoung Dev ๐ฅ
[ํ์ด์ฌ] ์๊ณ ๋ฆฌ์ฆ ํจ๋ฌ๋ค์ : Brute Force ๋ณธ๋ฌธ
2023.02.24 ์ฝ๋์ ํ์ต๋ด์ฉ
๐ ์๊ณ ๋ฆฌ์ฆ ํจ๋ฌ๋ค์(algorithm paradigm)
๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐ์๋ ์ฌ๋ฌ ๊ฐ์ง ๋ฐฉ์์ด ์์. ์ฌ๋ฌ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ค ๋ณด๋ฉด ํด๊ฒฐ ๊ณผ์ ์ด ๋น์ทํ ๊ฒฝ์ฐ๊ฐ ์๋๋ฐ, ์ด๋ฌํ ๊ฒ์ ์๊ณ ๋ฆฌ์ฆ ํจ๋ฌ๋ค์์ด๋ผ๊ณ ํจ. ์ฆ, ์ด๋ ํ ๋ฌธ์ ๋ฅผ ํ๊ธฐ ์ํ ์ผ๋ฐ์ ์ธ ์ ๊ทผ๋ฒ ํน์ ๋ฐฉ๋ฒ๋ก . ๋ช ๊ฐ์ง ์์ฃผ ์ฌ์ฉ๋๋ ์๊ณ ๋ฆฌ์ฆ ํจ๋ฌ๋ค์์ด ์์ผ๋ฉฐ, ๊ฐ ์๊ณ ๋ฆฌ์ฆ์ ๋ฌธ์ ๋ฅผ ํ๊ธฐ ์ํ ์์ ๋ง์ ๊ธฐ์ ๊ณผ ๋๊ตฌ๋ฅผ ๊ฐ์ง๊ณ ์์. ๋ํ, ํ๋์ ๋ฌธ์ ๋ฅผ ํธ๋ ๋ฐฉ๋ฒ์ ๋ค์ํ๊ธฐ ๋๋ฌธ์ ์ฌ๋ฌ ์๊ณ ๋ฆฌ์ฆ ํจ๋ฌ๋ค์์ผ๋ก ํ ๋ฌธ์ ์ ์ ๊ทผํ ์๋ ์์.
๊ฐ์ฅ ์์ฃผ ์ฌ์ฉ๋๋ ์๊ณ ๋ฆฌ์ฆ ํจ๋ฌ๋ค์
1. Greedy Algorithms
2. Divide and Conquer
3. Dynamic Programming
4. Backtracking
5. Branch and Bound
6. Randomized Algorithms
๐ Brute Force
Brute Force ์๊ณ ๋ฆฌ์ฆ์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๊ฐ์ฅ ๊ฐ๋จํ ์ ๊ทผ ๋ฐฉ๋ฒ์ผ๋ก ์ต์ ํ ํน์ ํด๋ฆฌ์คํฑ ๊ธฐ์ ์์ด ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ํ์ธํ์ฌ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ. ์ด ์๊ณ ๋ฆฌ์ฆ์ ๋ต์ด ๋์ฌ ๋๊น์ง ๊ฐ๋ฅํ ํด๊ฒฐ์ฑ ์ ํ๋์ฉ ๋ชจ๋ ์๋ํจ. ์ ๋ ฅ ๋ฐ์ดํฐ์ ๋ชจ๋ ๊ฐ๋ฅํ ์กฐํฉ ๋๋ ์์ด์ ๋ฐ๋ณตํ๊ณ , ๊ฐ๊ฐ์ ๋ฐ์ดํฐ๊ฐ ๋ฌธ์ ์ ์ฝ ์กฐ๊ฑด์ ์ถฉ์กฑํ๋์ง ํ์ธํจ์ผ๋ก์จ ์ํ
์ด ์๊ณ ๋ฆฌ์ฆ์ ๋ต์ ํ์คํ๊ฒ ์ฐพ์ ์ ์๊ณ , ๊ตฌํํ๊ธฐ๊ฐ ๊ฐ๋จํ์ง๋ง, ์ธํ ํฌ๊ธฐ๊ฐ ํฐ ๊ฒฝ์ฐ ๋งค์ฐ ๋๋ฆฌ๊ณ ๋นํจ์จ์ ์ผ ์ ์์. ๋ฐ๋ผ์ ์ด ๋ฐฉ๋ฒ์ ๋ค๋ฅธ ํด๊ฒฐ ๊ฐ๋ฅํ ์๊ณ ๋ฆฌ์ฆ ์๋ฃจ์ ์ด ์๊ฑฐ๋, ๋ฌธ์ ์ ํฌ๊ธฐ๊ฐ Brute Force ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ์ฌ๋ ์๊ด์์ ๋งํผ ์์ ๋ ์ฌ์ฉ.
๊ทธ๋ฌ๋ Brute Force ์๊ณ ๋ฆฌ์ฆ์ ๋ณด๋ค ํจ์จ์ ์ด๊ณ ์ ๊ตํ ์๊ณ ๋ฆฌ์ฆ ์ค๊ณ์ ๊ธฐ์ค ๋๋ ์์์ ์ด ๋๋ฏ๋ก ์ด ์๊ณ ๋ฆฌ์ฆ์ ๋ํ ์ดํด๊ฐ ํ์ํจ
๐ Brute Force ์ฐ์ต๋ฌธ์
โ ๋ ๊ฐ์ ๋ฆฌ์คํธ์์ ๋ ์์ ๊ณฑ์ด ๊ฐ์ฅ ํฐ ๊ฐ์ ์ถ๋ ฅํ๋ ๋ฌธ์
โผ Brute Force ์๊ณ ๋ฆฌ์ฆ ํจ๋ฌ๋ค์ ๋ฐฉ์๋ก ํผ ์ฝ๋(๋ชจ๋ฒ๋ต์) โผ
โ ์ค์ฒฉ for ๋ฐ๋ณต๋ฌธ์ผ๋ก ๊ฐ๋ฅํ ๋ชจ๋ ๋ ์์ ๊ณฑ์ ๊ฒฝ์ฐ์ ์๋ฅผ ๋์ถ
โก ํ์ฌ๊น์ง์ ์ต๋๊ฐ์ ๋ด๊ธฐ์ํด ์๊ธฐ ์์ ์ ๋ณ์๋ก ๊ฐ์ง๋ ๋ณ์(max_product)๋ฅผ ์ฌ์ฉํ์ฌ ํ์ฌ๊น์ง์ ์ต๋๊ฐ๊ณผ for๋ฌธ์์์ ๋ ์์ ๊ณฑ์ ๋น๊ต → ๋ ์์ ๊ณฑ์ด ํ์ฌ๊น์ง์ ์ต๋๊ฐ๋ณด๋ค ํฌ๋ฉด max_product๋ก ๋์
์๋ steps
left_cards = [1, 6, 5], right_cards = [4, 2, 3]
max_product = left_cards[0] * right_cards[0] → 4
max_product = max(max_product, 1 * 4) = max(4, 4) → 4
max_product = max(max_product, 1 * 2) = max(4, 2) → 4
max_product = max(max_product, 1 * 3) = max(4, 3) → 4
max_product = max(max_product, 6 * 4) = max(4, 24) → 24
max_product = max(max_product, 6 * 2) = max(24, 12) → 24
max_product = max(max_product, 6 * 3) = max(24, 18) → 24
max_product = max(max_product, 5 * 4) = max(24, 20) → 24
max_product = max(max_product, 5 * 2) = max(24, 10) → 24
max_product = max(max_product, 5 * 3) = max(24, 15) → 24
return max_product → 24
โป ์๊ฐ ๋ณต์ก๋
len(left_cards)๋ฅผ n, len(right_cards)๋ฅผ m์ด๋ผ๊ณ ํ์ ๋, ํจ์ max_product์ ์๊ฐ ๋ณต์ก๋๋ O(mn)
→ left_cards๋ฅผ ๋๋ for ๋ฐ๋ณต๋ฌธ n๋ฒ๊ณผ right_cards๋ฅผ ๋๋ for ๋ฐ๋ณต๋ฌธ m์ด ์ค์ฒฉ๋์ด ์๊ธฐ ๋๋ฌธ
โผ ๋ด๊ฐ ์์ฑํ ์ฝ๋ โผ
๊ณตํต์ : for ๋ฐ๋ชฉ๋ฌธ ์ค์ฒฉ ์ฌ์ฉํ์ฌ ์ผ์ชฝ ์นด๋์ ์ค๋ฅธ์ชฝ ์นด๋์ ๊ณฑ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ฝ์
์ฐจ์ด์ : โ ๋ ์์ ๊ณฑ์ ๊ฐ์ผ๋ก ๊ฐ์ง๋ ๋น ๋ฆฌ์คํธ(multi)๋ฅผ ๋ง๋ค๊ณ , ๋ฐ๋ณต๋ฌธ์์ ๋น ๋ฆฌ์คํธ์ ๋ ์์ ๊ณฑ ์ถ๊ฐ
โก ๋ชจ๋ ๊ฒฝ์ฐ์ ์์ ๋ํ ๊ณฑ(๊ฐ)์ ๊ฐ์ง๋ multi ๋ฆฌ์คํธ์ ์์ ์ค ์ต๋๊ฐ return
โ ์ง์ ๊ฑฐ๋ฆฌ๊ฐ ๊ฐ์ฅ ๊ฐ๊น์ด ๋ ๋งค์ฅ ์ฐพ๊ธฐ
โผ ๋ชจ๋ฒ๋ต์ โผ
โ ๊ฐ์ฅ ๊ฐ๊น์ด ๋ ๋งค์ฅ์ ๋ณ์๋ก ์ฌ์ฉ(pair)ํ์ฌ ๋ ๊ฐ๊น์ด ๋ ๋งค์ฅ์ ์ฐพ์ผ๋ฉด ๋ณ์(pair)๋ฅผ ์ ๋ฐ์ดํธํ๋ ๋ฐฉ๋ฒ์ผ๋ก ์์ฑ
โก ๊ฐ์ ์์น, ๊ฒ์ฌ๋ฅผ ์งํํ๋ ํํ ์์ ๊ฒฝ์ฐ์ ์์์ ์ ์ธํ๊ธฐ ์ํด i์ j์ ๋ฒ์ ์ง์ → ์ธ๋ฑ์ค ํ์ฉ
โผ ๋ด๊ฐ ์์ฑํ ์ฝ๋ โผ
๊ณตํต์ : for ๋ฐ๋ณต๋ฌธ 2๋ฒ ์ฌ์ฉํ์ฌ ๋ชจ๋ ๊ฒฝ์ฐ์ ์ ๊ณ์ฐ
์ฐจ์ด์ : โ ๋ ๋งค์ฅ์ด ์๋ ์ต์ ๊ฑฐ๋ฆฌ(min_distance)๋ฅผ ๋ณ์๋ก ์ฌ์ฉ
โก ์ธ๋ฑ์ค ๋์ ์กฐ๊ฑด๋ฌธ store1 < store2์ ์ฌ์ฉํ์ฌ ๊ฐ์ ์์น, ์ด์ ์ ๊ณ์ฐํ๋ ์์น๋ ๋ฐ๋ณต ๊ณ์ฐํ์ง ์๋๋ก ์ค์
→ ์๋ชป๋ ์ฝ๋๋ก ์์ ํ์ (๋ชจ๋ฒ ๋ต์๊ณผ ๊ฐ์ด for๋ฌธ์์ ๋ฐ๋ณตํ๋ ๋์์ ํํ ์์ฒด๊ฐ ์๋ ์ธ๋ฑ์ค๋ก ๋ณ๊ฒฝํด์ผ ํจ)
โข ๊ทธ ํ ์ต์ ๊ฑฐ๋ฆฌ์ธ ๊ฐ๊ฒ๋ค์ ์์น ๊ฐ์ ์ถ์ถํ๊ธฐ ์ํด ์กฐ๊ฑด๋ฌธ ์ฌ์ฉ. store1๊ณผ store2 ์ฌ์ด์ ๊ฑฐ๋ฆฌ๊ฐ ์ต์ ๊ฑฐ๋ฆฌ์ผ ๋ closest_pair์ store1, store2 ์ ์ฅ ํ ๋ฐ๋ณต๋ฌธ์ด ๋๋๋ฉด closest_pair ๋ฆฌํด
ํํ ํฌ๊ธฐ ๋น๊ต
๋ ํํ์ ์ฒซ ๋ฒ์งธ ์์๋ถํฐ ์์ํ์ฌ ์์๋ณ๋ก ๋น๊ต
๋จผ์ ๋ ์์๊ฐ ๋์ผํ ์ ํ์ธ์ง ํ์ธ
๊ทธ ๋ค์ ๊ฐ์ ๊ธฐ์ค์ผ๋ก ๋น๊ต → ๊ฐ์ ๊ธฐ์ค์ผ๋ก ๋น๊ตํ ๋ ์ฒซ ๋ฒ์งธ ์์๋ง ๋น๊ตํ๊ณ ๋๋จธ์ง ์์๋ ๋ฌด์
store1 < store2 ์ง์ ๋์ ํด ๋ณด๋ฉด ์๋ํ ๋๋ก ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ฐ์ง์ง ์์. (12,30) (12,10)๊ณผ์ ๋น๊ต๊ฐ ๋น ์ง.
→ ์๋ชป๋ ์ฝ๋. ๋ฐ๋ผ์ ๋ชจ๋ฒ๋ต์๊ณผ ๊ฐ์ด ์ธ๋ฑ์ค๋ฅผ ์ฌ์ฉํ ์ฝ๋๋ก ๋ณ๊ฒฝํด์ผ ํจ
(2, 3) (12, 30)
(2, 3) (40, 50)
(2, 3) (5, 1)
(2, 3) (12, 10)
(2, 3) (3, 4)
(12, 30) (2, 3)
(12, 30) (40, 50)
(12, 30) (5, 1)
(12, 30) (12, 10)
(12, 30) (3, 4)
(40, 50) (2, 3)
(40, 50) (12, 30)
(40, 50) (5, 1)
(40, 50) (12, 10)
(40, 50) (3, 4)
(5, 1) (2, 3)
(5, 1) (12, 30)
(5, 1) (40, 50)
(5, 1) (12, 10)
(5, 1) (3, 4)
(12, 10) (2, 3)
(12, 10) (12, 30)
(12, 10) (40, 50)
(12, 10) (5, 1)
(12, 10) (3, 4)
(3, 4) (2, 3)
(3, 4) (12, 30)
(3, 4) (40, 50)
(3, 4) (5, 1)
(3, 4) (12, 10)
์ฐธ๊ณ ๋งํฌ : https://www.delftstack.com/ko/howto/python/python-tuple-comparison/
์์ ๋ ๋ฌธ์ ๋ฅผ ํ๊ณ ๋๋ ์ ์ Brute Force ์๊ณ ๋ฆฌ์ฆ์์๋ ๊ตฌํ๊ณ ์ ํ๋ ๊ฒ์ ๋ณ์๋ก ์ค์ ํ๊ณ , ์ํ๋ ๊ฐ์ ์ฐพ์ผ๋ฉด ์ ๋ฐ์ดํธํ์ฌ return ํ๋ ๋ฐฉ์์ผ๋ก ์งํ
โ ๊ฑด๋ฌผ๊ณผ ๊ฑด๋ฌผ ์ฌ์ด์ ์ผ๋ง๋งํผ์ ๋น๋ฌผ์ด ๋ด๊ธธ ์ ์๋์ง ๊ณ์ฐ
โผ ๋ชจ๋ฒ๋ต์ โผ
โ ํ๋์ ์ธ๋ฑ์ค์ ๋ํ์ฌ ํด๋น ์ธ๋ฑ์ค๊ฐ ๊ฐ์ง ์ ์๋ ๋น๋ฌผ์ ์์ ๊ตฌํจ
โก for๋ฌธ ์ฌ์ฉํ์ฌ ๊ฐ๊ฐ์ ์ธ๋ฑ์ค์ ๋ํ ๋น๋ฌผ์ ์์ ํฉํจ
โข ์ด ๋ max ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ์์ ๋ณด๋ค ์ผ์ชฝ ํน์ ์ค๋ฅธ์ชฝ ๊ธฐ๋ฅ ๋์ด๊ฐ ๋ฎ์ ๊ฒฝ์ฐ์๋ ํฉํ์ง ์๋๋ก ์ค๊ณ
โผ ๋ด๊ฐ ์์ฑํ ์ฝ๋ โผ
โ ๊ท์น์ ์ด๋ ์ ๋ ํ์ ํ๋๋ฐ ์ด๋ป๊ฒ ์ฝ๋๋ก ๊ตฌํํด์ผ ํ ์ง๋ฅผ ๋ชฐ๋ผ์ ํํธ๋ฅผ ์ฐธ๊ณ ํ์ (ํ์ฌ ์ธ๋ฑ์ค์์ ๋ฐ์ ์ ์๋ ๋น๋ฌผ์ ์ ๊ตฌํ๊ธฐ๊น์ง)
โก for ๋ฐ๋ณต๋ฌธ๊ณผ ๋น๋ฌผ์ ์ด๋ ๊ตฌํ๋ ์ฝ๋๋ ์ง์ ์์ฑ → ํ์ฌ ์ธ๋ฑ์ค๊ฐ ๋ฐ์ ์ ์๋ ๋น๋ฌผ์ ์์ ๋ณ์์ ๋์ ํ๊ณ , max ๋์ if ์กฐ๊ฑด๋ฌธ์ ์ฌ์ฉํ์ฌ ์์ฑ
โข ๋๋์ : ๋ฌธ์ ๋ฅผ ์๊ฒ ์ชผ๊ฐ์ ์๊ฐํ๊ณ ๊ท์น ์๊ฐํ๊ธฐ. ์๊ฐ๋๋ ๊ท์น์ ์ ๋ฆฌํด์ ์ฝ๋๋ก ์ง์ ๊ตฌํํด ๋ณด๊ธฐ.