[๋ฐฑ์ค/python] 2805๋ฒ : ๋๋ฌด ์๋ฅด๊ธฐ
๋ฌธ์
์๊ทผ์ด๋ ๋๋ฌด M๋ฏธํฐ๊ฐ ํ์ํ๋ค. ๊ทผ์ฒ์ ๋๋ฌด๋ฅผ ๊ตฌ์ ํ ๊ณณ์ด ๋ชจ๋ ๋งํด๋ฒ๋ ธ๊ธฐ ๋๋ฌธ์, ์ ๋ถ์ ๋ฒ๋ชฉ ํ๊ฐ๋ฅผ ์์ฒญํ๋ค. ์ ๋ถ๋ ์๊ทผ์ด๋ค ์ง ๊ทผ์ฒ์ ๋๋ฌด ํ ์ค์ ๋ํ ๋ฒ๋ชฉ ํ๊ฐ๋ฅผ ๋ด์ฃผ์๊ณ , ์๊ทผ์ด๋ ์๋ก ๊ตฌ์ ํ ๋ชฉ์ฌ์ ๋จ๊ธฐ๋ฅผ ์ด์ฉํด์ ๋๋ฌด๋ฅผ ๊ตฌํ ๊ฒ์ด๋ค.
๋ชฉ์ฌ์ ๋จ๊ธฐ๋ ๋ค์๊ณผ ๊ฐ์ด ๋์ํ๋ค. ๋จผ์ , ์๊ทผ์ด๋ ์ ๋จ๊ธฐ์ ๋์ด H๋ฅผ ์ง์ ํด์ผ ํ๋ค. ๋์ด๋ฅผ ์ง์ ํ๋ฉด ํฑ๋ ์ด ๋ ์ผ๋ก๋ถํฐ H๋ฏธํฐ ์๋ก ์ฌ๋ผ๊ฐ๋ค. ๊ทธ ๋ค์, ํ ์ค์ ์ฐ์ํด์๋ ๋๋ฌด๋ฅผ ๋ชจ๋ ์ ๋จํด๋ฒ๋ฆฐ๋ค. ๋ฐ๋ผ์, ๋์ด๊ฐ H๋ณด๋ค ํฐ ๋๋ฌด๋ H ์์ ๋ถ๋ถ์ด ์๋ฆด ๊ฒ์ด๊ณ , ๋ฎ์ ๋๋ฌด๋ ์๋ฆฌ์ง ์์ ๊ฒ์ด๋ค. ์๋ฅผ ๋ค์ด, ํ ์ค์ ์ฐ์ํด์๋ ๋๋ฌด์ ๋์ด๊ฐ 20, 15, 10, 17์ด๋ผ๊ณ ํ์. ์๊ทผ์ด๊ฐ ๋์ด๋ฅผ 15๋ก ์ง์ ํ๋ค๋ฉด, ๋๋ฌด๋ฅผ ์๋ฅธ ๋ค์ ๋์ด๋ 15, 15, 10, 15๊ฐ ๋ ๊ฒ์ด๊ณ , ์๊ทผ์ด๋ ๊ธธ์ด๊ฐ 5์ธ ๋๋ฌด์ 2์ธ ๋๋ฌด๋ฅผ ๋ค๊ณ ์ง์ ๊ฐ ๊ฒ์ด๋ค. (์ด 7๋ฏธํฐ๋ฅผ ์ง์ ๋ค๊ณ ๊ฐ๋ค) ์ ๋จ๊ธฐ์ ์ค์ ํ ์ ์๋ ๋์ด๋ ์์ ์ ์ ๋๋ 0์ด๋ค.
์๊ทผ์ด๋ ํ๊ฒฝ์ ๋งค์ฐ ๊ด์ฌ์ด ๋ง๊ธฐ ๋๋ฌธ์, ๋๋ฌด๋ฅผ ํ์ํ ๋งํผ๋ง ์ง์ผ๋ก ๊ฐ์ ธ๊ฐ๋ ค๊ณ ํ๋ค. ์ด๋, ์ ์ด๋ M๋ฏธํฐ์ ๋๋ฌด๋ฅผ ์ง์ ๊ฐ์ ธ๊ฐ๊ธฐ ์ํด์ ์ ๋จ๊ธฐ์ ์ค์ ํ ์ ์๋ ๋์ด์ ์ต๋๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ๋๋ฌด์ ์ N๊ณผ ์๊ทผ์ด๊ฐ ์ง์ผ๋ก ๊ฐ์ ธ๊ฐ๋ ค๊ณ ํ๋ ๋๋ฌด์ ๊ธธ์ด M์ด ์ฃผ์ด์ง๋ค. (1 ≤ N ≤ 1,000,000, 1 ≤ M ≤ 2,000,000,000)
๋์งธ ์ค์๋ ๋๋ฌด์ ๋์ด๊ฐ ์ฃผ์ด์ง๋ค. ๋๋ฌด์ ๋์ด์ ํฉ์ ํญ์ M๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ธฐ ๋๋ฌธ์, ์๊ทผ์ด๋ ์ง์ ํ์ํ ๋๋ฌด๋ฅผ ํญ์ ๊ฐ์ ธ๊ฐ ์ ์๋ค. ๋์ด๋ 1,000,000,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ ์ ์ ๋๋ 0์ด๋ค.
์ถ๋ ฅ
์ ์ด๋ M๋ฏธํฐ์ ๋๋ฌด๋ฅผ ์ง์ ๊ฐ์ ธ๊ฐ๊ธฐ ์ํด์ ์ ๋จ๊ธฐ์ ์ค์ ํ ์ ์๋ ๋์ด์ ์ต๋๊ฐ์ ์ถ๋ ฅํ๋ค.
์ ๋ต
import math
N, M = map(int, input().split()) # N = ๋๋ฌด ๊ฐ์ / M = ํ์ํ ๋๋ฌด ๊ธธ์ด
tree = list(map(int, input().split()))
min = min(tree)
max = max(tree)
sum = sum(tree)
get = (sum - (min * N)) # pivot์ min์ผ๋ก ํ์ ๋ ๊ฐ์ ธ๊ฐ ๋๋ฌด ๊ธธ์ด
def binary(p):
g = 0
for t in tree:
if p < t:
g += (t - p)
return g
if get < M: # ๊ฐ์ ธ๊ฐ ๋๋ฌด๊ฐ ํ์ํ ๋๋ฌด๋ณด๋ค ์ ์ ๋
print(min - math.ceil((M-get) / N))
elif get == M: # ๊ฐ์ ธ๊ฐ ๋๋ฌด๊ฐ ํ์ํ ๋๋ฌด์ ๊ฐ์ ๋
print(min)
else: # ๊ฐ์ ธ๊ฐ ๋๋ฌด๊ฐ ํ์ํ ๋๋ฌด๋ณด๋ค ๋ง์ ๋
cut = 0
while max >= min:
pivot = (max + min) // 2
get = binary(pivot) # ์ด์งํ์
if get < M: # ์ด์งํ์ ๊ฒฐ๊ณผ๊ฐ ํ์ํ ๋๋ฌด๋ณด๋ค ์ ์ ๋
max = pivot - 1
elif get > M: # ์ด์งํ์ ๊ฒฐ๊ณผ๊ฐ ํ์ํ ๋๋ฌด๋ณด๋ค ๋ง์ ๋
cut = pivot
min = pivot + 1
else:
cut = pivot
break
print(cut)
N๊ฐ์ ๋๋ฌด ์ค ๊ฐ์ฅ ์์ ๋๋ฌด๋ฅผ min์ ๊ฐ์ฅ ํฐ ๋๋ฌด๋ฅผ max์ ๋ชจ๋ ๋๋ฌด์ ํฉ์ sum์ ์ ์ฅํ๋ค.
๊ฐ์ฅ ์์ ๋๋ฌด์ ๋์ด min์ ๊ธฐ์ค์ผ๋ก ์ ๋จ๊ธฐ์ ๋์ด๋ฅผ ์ค์ ํ๋ค.
min ๋์ด๋งํผ ๋๋ฌด๋ฅผ ์๋์ ๋, min ๊ฐ๋ณด๋ค ์์ ๋๋ฌด๋ ์์ผ๋ฏ๋ก ๊ฐ์ ธ๊ฐ ๋๋ฌด์ ๊ธธ์ด get ์ sum - (min*N)์ด ๋๋ค.
if get < M: # ๊ฐ์ ธ๊ฐ ๋๋ฌด๊ฐ ํ์ํ ๋๋ฌด๋ณด๋ค ์ ์ ๋
print(min - math.ceil((M-get) / N))
elif get == M: # ๊ฐ์ ธ๊ฐ ๋๋ฌด๊ฐ ํ์ํ ๋๋ฌด์ ๊ฐ์ ๋
print(min)
๊ฐ์ ธ๊ฐ ๋๋ฌด get์ด ํ์ํ ๋๋ฌด M๋ณด๋ค ์ ๋ค๋ฉด ์ ๋จ๊ธฐ์ ๋์ด๋ฅผ ๋ฎ์ถฐ์ผํ๋ค.
์ด๋ ๋ชจ์๋ ๋๋ฌด์ ๊ธธ์ด M-get์ ๋ชจ๋ ๋๋ฌด์์ ๊ณตํํ๊ฒ ๊ฐ์ ธ์ ์ฑ์ฐ๋ฉด ๋๋ฏ๋ก N์ผ๋ก ๋๋ ํ ์ฌ๋ฆผํ๋ค.
๊ทธ ๊ธธ์ด๋งํผ ๋ฐ์์ ๋๋ฌด๋ฅผ ์๋ผ์ผ ํ๋ฏ๋ก ์ ๋จ๊ธฐ์ ๋์ด๋ min - math.ceil((M-get) / N)์ด ๋๋ค.
๊ฐ์ ธ๊ฐ ๋๋ฌด get๊ณผ ํ์ํ ๋๋ฌด M์ ๊ธธ์ด๊ฐ ๊ฐ๋ค๋ฉด ์ ํํ ๋์ด์์ ์๋๋ค๋ ์๋ฏธ์ด๋ฏ๋ก
์ ๋จ๊ธฐ์ ๋์ด์๋ min์ ์ถ๋ ฅํ๋ค.
์ด์ ๋ฌธ์ ๋ ๋๋ฌด ๋ง์ ๋๋ฌด๋ฅผ ์๋์ ๋์ด๋ค.
๊ฐ์ ธ๊ฐ ๋๋ฌด get์ด ํ์ํ ๋๋ฌด M๋ณด๋ค ๋ง๋ค๋ฉด ์ ๋จ๊ธฐ์ ๋์ด๋ฅผ ๋์ฌ์ผํ๋ค.
else: # ๊ฐ์ ธ๊ฐ ๋๋ฌด๊ฐ ํ์ํ ๋๋ฌด๋ณด๋ค ๋ง์ ๋
cut = 0
while max >= min:
pivot = (max + min) // 2
get = binary(pivot) # ์ด์งํ์
์ต์ min๋ถํฐ ์ต๋ max์ ๋์ด๊น์ง์ ๋ฒ์์์ ์ด์งํ์์ผ๋ก ์ฐพ๋๋ค.
pivot์ ํด๋น ๋ฒ์์ ์ค๊ฐ์ผ๋ก ์ค์ ํ๊ณ get์ ์ด์งํ์ํ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํ๋ค.
def binary(p):
g = 0
for t in tree:
if p < t:
g += (t - p)
return g
binary ํจ์์์๋ pivot๊ฐ์ ๋ฐ์์ฌ p๋ฅผ ๋ชจ๋ ๋๋ฌด์ ๊ธธ์ด์ ๋น๊ตํ๋ค.
๋ง์ฝ p๊ฐ ๋๋ฌด์ ๊ธธ์ด t๋ณด๋ค ์๋ค๋ฉด ์ ๋จ๊ธฐ๋ก ์๋ฅผ ์ ์๋ค๋ ์๋ฏธ์ด๋ฏ๋ก
g์ ์ ๋จ๊ธฐ ๋์ด p๋งํผ ์๋ฅธ ๋๋จธ์ง t-p๋ฅผ ๋ํ๋ค.
if get < M: # ์ด์งํ์ ๊ฒฐ๊ณผ๊ฐ ํ์ํ ๋๋ฌด๋ณด๋ค ์ ์ ๋
max = pivot - 1
elif get > M: # ์ด์งํ์ ๊ฒฐ๊ณผ๊ฐ ํ์ํ ๋๋ฌด๋ณด๋ค ๋ง์ ๋
cut = pivot
min = pivot + 1
else:
cut = pivot
break
์ด์ binary ํจ์๋ฅผ ํตํด ๋ฐ์์จ get๊ณผ ํ์ํ ๋๋ฌด์ ๊ธธ์ด M์ ๋น๊ตํ๋ค.
๋ง์ฝ ๊ฒฐ๊ณผ get์ด ํ์ํ ๋๋ฌด M๋ณด๋ค ์ ๋ค๋ฉด ์ ๋จ๊ธฐ์ ๋์ด๋ฅผ ๋ฎ์ถฐ์ผํ๋ฏ๋ก ์ต๋๊ฐ max๋ฅผ pivot-1๋ก ์ค์ ํ๋ค.
๋ง์ฝ ๊ฒฐ๊ณผ get์ด ํ์ํ ๋๋ฌด M๋ณด๋ค ๋ง๋ค๋ฉด ์ ๋จ๊ธฐ์ ๋์ด๋ฅผ ๋์ฌ์ผํ๋ฏ๋ก ์ต์๊ฐ min์ pivot+1๋ก ์ค์ ํ๋ค.
๐ฅ ์ด๋ get์ด M๋ณด๋ค ๋ง๋๋ผ๋ ํด๋น pivot์ด ์ต์ ์ ๊ฐ์ผ ์ ์์ผ๋ฏ๋ก, ๋ฐ๋ก cut์ pivot ๊ฐ์ ์ ์ฅํด๋์ด์ผ ํ๋ค.
๋ง์ฝ ๊ฒฐ๊ณผ get๊ณผ ํ์ํ ๋๋ฌด M์ด ๊ฐ๋ค๋ฉด ์ต์ ์ ๋์ด์ด๋ฏ๋ก cut์ pivot ๊ฐ์ ์ ์ฅํ๊ณ ๋ฐ๋ณต๋ฌธ์ ๋น ์ ธ๋์จ๋ค.
๋ฐ๋ณต๋ฌธ์ ์คํํ๋ฉด์ max ๊ฐ์ด min ๊ฐ๋ณด๋ค ์์์ง๋ฉด ๊ฐ๋ฅํ ๊ฒฝ์ฐ์ ์์ ์ด์งํ์์ ๋ง์ณค๋ค๋ ๋ป์ด๋ค.
get๊ณผ M์ด ์ผ์นํ๋ ์๊ฐ์ด ์์๋ค๋ฉด ๋๋ฒ์งธ ์กฐ๊ฑด๋ฌธ์์ get์ด M๋ณด๋ค ํฐ ์๊ฐ์ pivot์ด cut์ ์ ์ฅ๋์์ ๊ฒ์ด๋ค.
cut์ ์ ์ฅ๋ ๊ฐ์ด ์ ๋จ๊ธฐ์ ๋์ด์ด๋ฏ๋ก ํด๋น ๊ฐ์ ์ถ๋ ฅํด์ค๋ค.
์ด์งํ์์ ๋ํ ์์ธํ ์ค๋ช ์ ์๋ ํฌ์คํ ์ ์ฐธ๊ณ ํ๋ฉด ๋๋ค.
2021.03.17 - [๐์๊ณ ๋ฆฌ์ฆ/๐ ๊ฐ๋ ์ ๋ฆฌ] - [python] ์ด์ง ํ์ (Binary Search)
[ํ์ด์ฌ/python] ์ด์ง ํ์ (Binary Search)
์ด์ง ํ์์ด๋ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋ ๋ฐฐ์ด์์ ์ํ๋ ์ซ์๋ฅผ ์ฐพ๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ๋ฐ๋์ ์ ๋ ฌ๋ ์ํ์์ ์์ํด์ผํ๊ณ ๋ก๊ทธ์คํ์๊ฐ(O(log N))์ ๋ณด์ฅํ๋ค. target : ์ฐพ์ ๊ฐ start : ์์ ์ธ๋ฑ์ค end
ye333.tistory.com
'๐์๊ณ ๋ฆฌ์ฆ > ๋ฐฑ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฐฑ์ค/python] 4949๋ฒ : ๊ท ํ์กํ ์ธ์ (0) | 2021.03.12 |
---|---|
[๋ฐฑ์ค/python] 11651๋ฒ : ์ขํ ์ ๋ ฌํ๊ธฐ 2 (0) | 2021.03.11 |
[๋ฐฑ์ค/python] 1929๋ฒ : ์์ ๊ตฌํ๊ธฐ (0) | 2021.03.09 |
[๋ฐฑ์ค/python] 10250๋ฒ : ACM ํธํ (0) | 2021.03.09 |
[๋ฐฑ์ค/python] 2869๋ฒ : ๋ฌํฝ์ด๋ ์ฌ๋ผ๊ฐ๊ณ ์ถ๋ค (0) | 2021.03.09 |