- @CreatedDate
- GIT
- OpenAPI
- aligoapi
- MAKE US
- Unity
- spring์ผ๋ก https ์ ์ฉ
- Data Structure
- MethodArgumentNotValidException
- RP 2๊ธฐ
- SSL
- ๊ตฌ๊ธ ์์ ๋ก๊ทธ์ธ
- ๋ฆฌ๋ ์ค ๋ช ๋ น์ด
- datagrip
- mysql
- C++
- merge sort
- DATABASE
- node js
- SQL
- spring ๊ตฌ๊ธ ์์ ๋ก๊ทธ์ธ
- spring ์์ ๋ก๊ทธ์ธ
- ํจ์คํธ์บ ํผ์คX์ผ๋์
- Quick Sort
- ์์คํ ์ํํธ์จ์ด
- java error
- docker
- Java
- Rp2๊ธฐ
- Spring
YS's develop story
๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ ์ ๋ฆฌ ๋ณธ๋ฌธ
๐ฉ๐ป ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ (ํ์๋ฒ) ์ ๋ฆฌ with Python
๐ฅ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ (Greedy Algorithm)์ด๋?
1. ๋งค ์๊ฐ ์ต์ ์ด๋ผ๊ณ ์๊ฐ๋๋ ๊ฒฝ์ฐ๋ฅผ ์ ํํ๋ ๋ฐฉ์์ผ๋ก ์งํํด์ ์ต์ข ์ ์ธ ๊ฐ์ ๊ตฌํ๋ ๋ฐฉ์์ ๋๋ค.
2. ๊ฐ๊ฐ์ ์ ํ์ ๊ทธ ์๊ฐ ๋ณด์์ ๋๋ ๊ฐ์ฅ ์ข์ ๋ณด์ด์ง๋ง ๋์ค์๋ ์ต์ ์ ํด๊ฐ ์๋ ์ ์์ต๋๋ค.
3. ์ฆ ๋งค ์๊ฐ์ ์ ํ์ locally optimal ํ์ง๋ง globally optimalํ์ง ์์ต๋๋ค.
๊ทธ๋ ๊ธฐ์ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ์ต์ ํด๋ฅผ ์ป์ ์ ์๋ ๊ฒ์ด ์กด์ฌํฉ๋๋ค.
๐ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ ์์ 1 - ๋์ ๋ฌธ์
์ง๋ถํด์ผ ํ๋ ๊ฐ์ด 7870์ ์ผ ๋ ๊ฐ์ฅ ์ ์ ์์ ๋์ผ๋ก ์ง๋ถํ๋ ๋ฐฉ๋ฒ์
๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ํ์ฉํ์ฌ ๊ตฌํ ์ ์์ต๋๋ค.
๊ฐ์ฅ ํฐ๋๋ถํฐ ์ต๋ํ ์ง๋ถํด์ผ ํ๋ ๊ฐ์ ์ฑ์ฐ๋ ๋ฐฉ์์ผ๋ก ๊ตฌํ๋๋ฉฐ
๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ๋งค ์๊ฐ ์ต์ ์ด๋ผ๊ณ ์๊ฐ๋๋ ๊ฒฝ์ฐ๋ฅผ ์ ํํ๋ฉด ๋ฉ๋๋ค.
๐ ๋์ ๋ฌธ์ ์ฝ๋
# Greedy1 - Coin Problem
coinList = [5000, 1000, 500, 100, 50, 10]
def greedy1(conList, value):
conList.sort(reverse=True)
totalCount = 0
details = list()
for i in conList:
count = value // i
totalCount += count
value -= count * i
details.append([i, count])
return totalCount, details
print(greedy1(coinList, 7870))
๐ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ ์์ 2 - Fractional Knapsack Problem
๋ฌด๊ฒ ์ ํ์ด k์ธ ๋ฐฐ๋ญ์ ์ต๋ ๊ฐ์น๋ฅผ ๊ฐ์ง๋๋ก ๋ฌผ๊ฑด์ ๋ฃ๋ ๋ฌธ์ ์ ๋๋ค.
๊ฐ ๋ฌผ๊ฑด์ ๋ฌด๊ฒ w์ ๊ฐ์น v๋ก ํํ๋ ์ ์์ต๋๋ค.
๋ฌผ๊ฑด์ ์ชผ๊ฐค ์ ์๊ณ ๋ฌผ๊ฑด์ ์ผ๋ถ๋ถ์ ๋ฐฐ๋ญ์ ๋ฃ์ ์ ์์ต๋๋ค.
๐ Fractional Knapsack Problem ์ฝ๋
# Greedy2 - Fractional Knapsack Problem
dataList = [(10, 10), (15, 12), (20, 10), (25, 8), (30, 5)]
def knapsack(dataList, capacity):
dataList = sorted(dataList, key=lambda x: x[1] / x[0], reverse=True)
details = list()
totalValue = 0
for i in dataList:
if capacity - i[0] >= 0:
capacity -= i[0]
totalValue += i[1]
details.append([i[0], i[1], 1])
else:
fractions = capacity / i[0]
totalValue += fractions * i[1]
details.append([i[0], i[1], fractions])
break
return totalValue, details
print(knapsack(dataList, 30))
๐ฅญ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ํ๊ณ
๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋ฐ๋์ ์ต์ ์ ํด๋ฅผ ๊ตฌํ ์ ์๋ ์๊ณ ๋ฆฌ์ฆ์ด ์๋๋๋ค.
๊ทธ ์๊ฐ์ ๊ฐ์ฅ ์ข์ ๋ณด์ด๋ ์ ํ์ ํตํด ์ต์ ์ ํด์ ๊ฐ๊น์ด ๊ฐ์ ๊ตฌํ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค.
๊ทธ๋ ๊ธฐ์ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก๋ ์ต์ ํด๋ฅผ ๊ตฌํ ์ ์๋ ๋ฌธ์ ๋ ์์ต๋๋ค.
์ ๊ทธ๋ํ์์ ๊ฐ์ฅ ์์ ๊ฐ์ ์ฐพ์ leaf node๊น์ง ๊ฐ๋ ๊ฒฝ๋ก๋ฅผ ์ฐพ๋ ๋ฌธ์ ์์...
๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ๊ฐ์ฅ ์์ ๊ฐ์ ์ฐพ์ ๊ฒฝ๋ก๋ฅผ ์ฐพ๋๋ค๋ฉด 7 -> 12 = 19 ์ผ ๊ฒ์ ๋๋ค.
ํ์ง๋ง ์ค์ ๋ก ๊ฐ์ฅ ์์ ๊ฐ์ 10 -> 5์ด๋ฉฐ 15๊ฐ ๊ตฌํ๊ณ ์ ํ๋ ๊ฐ์ ๋๋ค.
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ ์ ๋ฆฌ (0) | 2021.08.14 |
---|---|
๋๋น ์ฐ์ ํ์ (BFS), ๊น์ด ์ฐ์ ํ์ (DFS) ์ ๋ฆฌ (0) | 2021.08.03 |
์์ฐจ ํ์, ์ด์ง ํ์ ์ ๋ฆฌ (2) | 2021.08.01 |
ํต ์ ๋ ฌ (Quick Sort) ์ ๋ฆฌ (0) | 2021.07.31 |
๋ณํฉ ์ ๋ ฌ (Merge Sort) ์ ๋ฆฌ (0) | 2021.07.31 |