๐ค๋ฌธ์ ํด๊ฒฐ
Lv4 | ์ด๋ถํ์ or ์์ ํ์(?)
์ด๋ถํ์์ผ๋ก ์ฝ๋๋ฅผ ๊ตฌํํ๋๋ ํจ์จ์ฑ์์ ์คํจํ๋ค.
๊ทธ๋์ ํ์ธตํ์ธต ๊ฐ์ ์ ์ฅํ๊ณ ๋ค์ ์ธต์ ๊ฐ์ ๊ตฌํ ๋๋ ์ด์ ์ ์ ์ฅํ ์ธต์ ๊ฐ์ ์ด์ฉํ๊ธฐ๋ก ํ๋ค.
๋จผ์ 2์ฐจ์ ํ๋ ฌ์ ์ผ๋ ฌ๋ก ์ธ์ด๊ณ ์ค๋ฆ์ฐจ์ ์ ๋ ฌํ๋ค.
[[4, 4, 3], [3, 2, 2], [2, 1, 0]] โก [0, 1, 2, 2, 2, 3, 3, 4, 4]
๋ค์ ์ ์ผ ๋ฎ์ ์ธต( ์ฌ๊ธฐ์๋ 0 )์ผ๋ก ํํํ๊ฒ ๋ง๋ค ๊ฒฝ์ฐ๋ฅผ ๊ตฌํ๋ค.
์งํ์ ๋นผ๋ ์์ ๋ง ํ๋ฉด ๋๋ฏ๋ก ( ์ ์ฒด์งํ ์ - ๊ฐ์ฅ ๋ฎ์์ธต์ ์งํ ์ ) * Q(๋นผ๋ ๋น์ฉ)
๋นจ๊ฐ ๋ถ๋ถ์ ๋ค ์ง์ฐ๋ฉด ๋์ด๊ฐ 0์ธ ํํํ ์งํ์ ๋ง๋ค ์ ์๋ค.
- ๊ฐ์ 21์นธ * Q(์ง์ฐ๋ ๊ฐ) = 63
์ด์ ์ผ๋ ฌ๋ก ์ธ์ด ๋ฆฌ์คํธ๋ฅผ ํ๋ํ๋ ํ์ํ๋ค. ( ๋งจ์์ ํ์ผ๋ 0๋ถํฐ )
๋ฆฌ์คํธ[1] ์ 1์ด๋ค. (1์ธต์ผ๋ก ํํํ๊ฒ ํ๋ค๋ ๋ป)
* ๋ก ํ์๋ ์ธต์ด ์์ฑ ๋์ด์ผ ํ๋ค. ์ด๋ก์นธ์ ์๋ ์๋๊ณณ์ด๊ณ , ๋นจ๊ฐ ์นธ์ ์๋ ์๋ ๊ณณ์ด๋ค.
0์ธต์ผ๋ก ๋ง๋๋ ๊ฐ(63)์ ์ด๋ก์นธ๊ณผ ๋นจ๊ฐ์นธ์ ๋ํด์ค์ผ ํ๋ค.
ํ์ง๋ง ์ด๋ก์นธ์ ์๋ก ์งํ์ ์ถ๊ฐํ๋ ๊ฒ์ด๊ณ , ๋นจ๊ฐ์นธ์ ๊ธฐ์กด์ ์ง์ ๋ ์งํ์ ๋ค์ ๋ณต๊ตฌํ๋ ๊ฒ์ด๋ค.
์๋ก ์งํ์ ์ถ๊ฐํ๋ ค๋ฉด +P, ๋ณต๊ตฌํ๋ ๊ฒ์ -Q์ ๊ฐ์ด ๋ ๋ค.( Q๋ฅผ ์จ์ ์ง์ ์ผ๋ Q๋ฅผ ์จ์ ๋ณต๊ตฌํ๋ค.)
- 0์ธต ๊ฐ + ์ด๋ก( (๋์ด ์ฐจ์ด)*(๊ฐ์)*P ) - ๋นจ๊ฐ ( (๋์ด ์ฐจ์ด)*(๋๋จธ์ง ๊ฐ์)*Q )
- 63 +5 - 24 = 44
๋ค์์ ๋ฆฌ์คํธ[2] = 2 ์ด๋ค.
๋๊ฐ์ ์ด๋ก ์งํ์ ์๋ก ์ถ๊ฐํ๊ณ , ๊ธฐ์กด์ ์ง์ ๋ 7๊ฐ์ ๋นจ๊ฐ ์งํ์ ๋ณต๊ตฌํ๋ค.
๋ค์ ๋ฆฌ์คํธ[3] = 2 ์ด๋ค. ์ด์ ์ ์งํํ 2์ธต๊ณผ ๋๊ฐ์ผ๋ฏ๋ก ํจ์ค... ์ด๋ฐ์์ผ๋ก ์ ์ผ ๊ณ ์ธต๊น์ง ์ฌ๋ผ๊ฐ๋ฉด ํด๊ฒฐ!
๐จ ์๊ฐ์ ์ค์ด๋ ํ์ ๋ฐ์์ ๊ณ ์ธต์ผ๋ก ๊ฐ ์๋ก ๋น์ฉ์ด ์ค์ด๋ค๊ณ ์ด๋ ์๊ฐ๋ถํฐ ๋ค์ ๋น์ฉ์ด ๋์ด๋๋ค.
์ฆ ๋ณ๊ณก์ ์ด ํ๋ ์๋ค. ๊ทธ ๋ถ๋ถ์ ๋ฉ์ถ๋ฉด ๋ ๋ฏํ๋ค( ์ด๋ถํ์์์ ๊ทธ๋ ๊ฒ ํ์ )
๐ป์์ค ์ฝ๋
from itertools import chain
def solution(land, P, Q):
# ์ผ๋ ฌ๋ก ์ธ์ฐ๊ธฐ
line = list(chain.from_iterable(land))
line.sort()
# print(line)
n = len(line)
# ๊ฐ์ฅ ๋ฎ์ ์ธต์ผ๋ก ํธ์ง (๋ฌด์กฐ๊ฑด 0์ด ์๋๋ผ ๊ฐ์ง๊ณ ์๋ ์ธต์ค์ ๋งจ ๋ฐ)
# ๊ฐ์ฅ ๋ฎ์ ์ธต์ ์งํ์ด ๋ค ์์ผ๋ฏ๋ก ๊ทธ ์์ ๋ธ๋ก์ ๋ชจ๋ ์ ๊ฑฐํ๋ฉด ๋๋ค.
cost = (sum(line) - line[0] * n) * Q
answer = cost
# ํ์ธต์ฉ ์๊ธฐ
for i in range(1, n):
if line[i] != line[i - 1]:
# print(f'cost: {cost}, line[i-1]: {line[i - 1]}, line[i]: {line[i]} ')
cost = cost + ((line[i] - line[i - 1]) * i * P) - ((line[i] - line[i - 1]) * (n - i) * Q)
if answer < cost: # ์๊ฐ ๋จ์ถ - ๋ณ๊ณก์
break
answer = min(answer, cost)
return answer
and ์คํจํ ์ฝ๋ ๐ข ( ์ด๋ถ ํ์ ) - ์ ํ์ฑ์ ๋ง์ผ๋ ํจ์จ์ฑ ํ ์คํธ ๋จ์ด์ง
์ด๋ถ ํ์
from collections import defaultdict
def solution(land, P, Q):
answer = 0
n = len(land)
line = defaultdict(int)
for i in range(n):
for j in range(n):
line[land[i][j]] += 1
# print(line)
def cal(k):
p, q = 0, 0
# print(f'i: {k}')
for key, value in line.items():
if key > k:
q += (key - k) * value
elif key < k:
p += (k - key) * value
# print(f'total: {p * P + q * Q}')
return p * P + q * Q
bottom = min(line)
top = max(line)
while True:
mid = (bottom + top) // 2
up_val = cal(mid + 1)
mid_val = cal(mid)
down_val = cal(mid - 1)
if mid_val <= up_val and mid_val <= down_val:
answer = mid_val
break
elif down_val < mid_val:
top = mid - 1
elif up_val < mid_val:
bottom = mid + 1
return answer
๐๋ฌธ์ ํ์ธ
์ถ์ฒ: ํ๋ก๊ทธ๋๋จธ์ค
๋งํฌ: https://programmers.co.kr/learn/courses/30/lessons/12984
๋ฌธ์ ์ค๋ช
XX ๊ฒ์์์๋ ์งํ ํธ์ง ๊ธฐ๋ฅ์ ์ด์ฉํ์ฌ ํ๋ ์ด์ด๊ฐ ์ง์ ๊ฒ์ ์ ์งํ์ ์์ ํ ์ ์์ต๋๋ค. ์ด ๊ฒ์์์๋ 1 x 1 x 1 ํฌ๊ธฐ์ ์ ์ก๋ฉด์ฒด ๋ธ๋ก์ ์์ ๊ฒ์ ์ ์งํ์ ํํํฉ๋๋ค. ์ด๋, ๋ธ๋ก์ด ๊ณต์ค์ ๋ ์๊ฑฐ๋, ๋ธ๋ก ํ๋๊ฐ ์ฌ๋ฌ ๊ฐ์ ์นธ์ ๊ฑธ์ณ ๋์ผ ์๋ ์์ต๋๋ค. ๋ฐ๋ผ์ ์งํ์ ํธ์งํ๊ธฐ ์ํด์๋ ๊ฐ ์นธ์ ์ ์ผ ์์ ๋ธ๋ก 1๊ฐ๋ฅผ ์๋ก ์ถ๊ฐํ๊ฑฐ๋, ์ ์ผ ์์ ์๋ ๋ธ๋ก ํ ๊ฐ๋ฅผ ์ญ์ ํ๋ ๋ฐฉ์์ผ๋ก ์งํ์ ์์ ํด์ผ ํฉ๋๋ค. ์ด๋, ๋ธ๋ก ํ ๊ฐ๋ฅผ ์๋ก ์ถ๊ฐํ๊ฑฐ๋ ์ญ์ ํ๊ธฐ ์ํด์๋ ๊ฒ์๋จธ๋๋ฅผ ์ฌ์ฉํด์ผ ํ๋ฏ๋ก ๋ช ๊ฐ์ ๋ธ๋ก์ ์ถ๊ฐํ๊ณ ์ญ์ ํ ์ง ์ ์คํ ์ ํ์ด ํ์ํฉ๋๋ค.
์ด ๊ฒ์์ ์ฆ๊ธฐ๋ ํ ํ๋ ์ด์ด๋ N x N ํฌ๊ธฐ์ ์ง์ญ์ ์์ ๋ง์ ๋ณ์ฅ์ ๋ง๋ค๊ณ ์ถ์ด์ก์ต๋๋ค. ์ด๋ฅผ ์ํด์๋ ์ธํ๋ถํํ ์งํ์ ๋ชจ๋ ์นธ์ ๋์ด๊ฐ ๊ฐ์์ง๋๋ก ๋ง๋ค์ด์ผ ํฉ๋๋ค. ์ด๋, ๋ธ๋ก ํ ๊ฐ๋ฅผ ์ถ๊ฐํ๋ ค๋ฉด P์ ๋น์ฉ์ด, ์ ๊ฑฐํ๋ ค๋ฉด Q์ ๋น์ฉ์ด ๋ค๊ฒ ๋ฉ๋๋ค.
๋ค์์ ๋ธ๋ก ํ ๊ฐ๋ฅผ ์ถ๊ฐํ ๋ 5์ ๋น์ฉ์ด, ์ ๊ฑฐํ ๋ 3์ ๋น์ฉ์ด ๋๋ ๊ฒฝ์ฐ, 3 x 3 ๋์ด์ ๋ชจ๋ ์นธ์ ๋ธ๋ก ๋์ด๊ฐ ๊ฐ์์ง๋๋ก ๋ง๋๋ ์์์
๋๋ค.
์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ์งํ ๋ธ๋ก์ด ๋์ฌ ์๋ ๊ฒฝ์ฐ ๋ชจ๋ ์นธ์ ๋์ด๊ฐ 3์ผ๋ก ๊ฐ์์ง๋๋ก ํ๋ค๋ฉด ๋ค์๊ณผ ๊ฐ์ ๋ชจ์์ด ๋ฉ๋๋ค.
์ด๋ฅผ ์ํด์๋ 3๋ณด๋ค ๋์ ์นธ์ ๋ธ๋ก 2๊ฐ๋ฅผ ์ ๊ฑฐํ๊ณ , 3๋ณด๋ค ๋ฎ์ ์นธ์ ์ด 8๊ฐ์ ๋ธ๋ก์ ์ถ๊ฐํด์ผ ํ๋ฉฐ, 2 x 3 + 8 x 5 = 46์ ๋น์ฉ์ด ๋ค๊ฒ ๋ฉ๋๋ค.
๊ทธ๋ฌ๋ ์๋ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ๋ชจ๋ ์นธ์ ๋์ด๊ฐ 2๋ก ๊ฐ์์ง๋๋ก ํ ๋๋ 6๊ฐ์ ๋ธ๋ก์ ์ ๊ฑฐํ๊ณ , 3๊ฐ์ ๋ธ๋ก์ ์ถ๊ฐํ๋ฉด 6 x 3 + 3 x 5 = 33์ ๋น์ฉ์ด ๋ค๊ฒ ๋๋ฉฐ, ์ด๋๊ฐ ์ต์๋น์ฉ์ด ๋ฉ๋๋ค.
ํ์ฌ ์งํ์ ์ํ๋ฅผ ๋ํ๋ด๋ ๋ฐฐ์ด land์ ๋ธ๋ก ํ ๊ฐ๋ฅผ ์ถ๊ฐํ๋ ๋ฐ ํ์ํ ๋น์ฉ P, ๋ธ๋ก ํ ๊ฐ๋ฅผ ์ ๊ฑฐํ๋ ๋ฐ ํ์ํ ๋น์ฉ Q๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ๋ชจ๋ ์นธ์ ์์ฌ์๋ ๋ธ๋ก์ ๋์ด๊ฐ ๊ฐ์์ง๋๋ก ํ๋ ๋ฐ ํ์ํ ๋น์ฉ์ ์ต์๊ฐ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์.
์ ํ์ฌํญ
- land๋ N x N ํฌ๊ธฐ์ 2์ฐจ์ ๋ฐฐ์ด์ด๋ฉฐ, N์ ๋ฒ์๋ 1 ≤ N ≤ 300์ ๋๋ค.
- land์ ๊ฐ ์์๋ ๊ฐ ์นธ์ ๋์ฌ ์๋ ๋ธ๋ก์ ์๋ฅผ ๋ํ๋ด๋ฉฐ, 0 ์ด์ 10์ต ์ดํ์ ์ ์์ ๋๋ค.
- ๊ฐ ์นธ์ ๋ธ๋ก ํ๋๋ฅผ ์ถ๊ฐํ๋ ๋ฐ๋ P, ์ ๊ฑฐํ๋ ๋ฐ๋ Q์ ๋น์ฉ์ด ๋ค๋ฉฐ, P, Q์ ๋ฒ์๋ 1 ≤ P, Q ≤ 100์ธ ์์ฐ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
land | P | Q | result |
[[1, 2], [2, 3]] | 3 | 2 | 5 |
[[4, 4, 3], [3, 2, 2], [ 2, 1, 0 ]] | 5 | 3 | 33 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
- ๋ชจ๋ ๋ ์ ๋์ด๋ฅผ 1๋ก ๋ง์ถ๋ ๋ฐ๋ ๋ธ๋ก 4๊ฐ๋ฅผ ์ ๊ฑฐํด์ผ ํ๋ฏ๋ก 8์ ๋น์ฉ์ด ๋ญ๋๋ค.
- ๋ชจ๋ ๋ ์ ๋์ด๋ฅผ 2๋ก ๋ง์ถ๋ ๋ฐ๋ ๋ธ๋ก 1๊ฐ๋ฅผ ์ถ๊ฐํ๊ณ ๋ธ๋ก 1๊ฐ๋ฅผ ์ ๊ฑฐํด์ผ ํ๋ฏ๋ก 5์ ๋น์ฉ์ด ๋ญ๋๋ค.
- ๋ชจ๋ ๋ ์ ๋์ด๋ฅผ 3์ผ๋ก ๋ง์ถ๋ ๋ฐ๋ ๋ธ๋ก 4๊ฐ๋ฅผ ์ถ๊ฐํด์ผ ํ๋ฏ๋ก 12์ ๋น์ฉ์ด ๋ญ๋๋ค.
๋ฐ๋ผ์ ์ต์ ๋น์ฉ์ 5์ด๋ฏ๋ก 5๋ฅผ return ํฉ๋๋ค.
์
์ถ๋ ฅ ์ #2
๋ฌธ์ ์ ์์์ ๊ฐ์ผ๋ฉฐ ์ต์ ๋น์ฉ์ 33์
๋๋ค.
'Algorithm Problem > Python' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[python] ํ๋ก๊ทธ๋๋จธ์ค - 3 x n ํ์ผ๋ง (0) | 2020.09.17 |
---|---|
[python] ๋ฐฑ์ค - 9658. ๋ ๊ฒ์4 (0) | 2020.09.16 |
[python] ํ๋ก๊ทธ๋๋จธ์ค - ์ซ์ ๋ธ๋ก (1) | 2020.09.15 |
[python] ํ๋ก๊ทธ๋๋จธ์ค - ๋จ์ด ํผ์ฆ(2017 ํ์คํ์ด) (0) | 2020.09.14 |
[python] ํ๋ก๊ทธ๋๋จธ์ค - ์ง๊ฒ๋ค๋ฆฌ (4) | 2020.09.13 |