๐ ๋ฌธ์ ํ์ํ๊ธฐ
- ์๊ทผ์ด๊ฐ ํ์๋ก ํ๋ ๋๋ฌด ๊ธธ์ด๋ M๋ฏธํฐ (1 ≤ M ≤ 2,000,000,000)
- ๋๋ฌด ํ ์ค์ N๊ฐ์ ๋๋ฌด(1 ≤ N ≤ 1,000,000) ์กด์ฌ
- ๋๋ฌด ๋์ด๋ 1,000,000,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ ์ ์ ๋๋ 0
- ๋ชฉ์ฌ์ ๋จ๊ธฐ์ ๋์ด H ์ง์ -> ํฑ๋ ์ด ๋
์ผ๋ก๋ถํฐ H๋ฏธํฐ ์๋ก ์ฌ๋ผ๊ฐ์ ํ ์ค์ ์ฐ์ํด์๋ ๋๋ฌด ๋ชจ๋ ์ ๋จ
- ๋์ด๊ฐ H๋ณด๋ค ํฐ ๋๋ฌด๋ H ์์ ๋ถ๋ถ์ด ์๋ฆฌ๊ณ , ๋ฎ์ ๋๋ฌด๋ ์๋ฆฌ์ง ์์
- ์๊ทผ์ด๋ ๋์ด H๋ณด๋ค ํฐ ๋๋ฌด์ ์๋ฆฐ ๋ถ๋ถ์ ๋๋ฌด๋ฅผ ๋ค๊ณ ๊ฐ
- ์ ์ด๋ M๋ฏธํฐ์ ๋๋ฌด๋ฅผ ์ง์ ๊ฐ์ ธ๊ฐ๊ธฐ ์ํด ์ ๋จ๊ธฐ์ ์ค์ ํ ์ ์๋ ๋์ด์ ์ต๋๊ฐ ๊ตฌํ๊ธฐ
๋๋ฌด์ ์ต๋ ๋์ด๊ฐ 1,000,000,000์ด๋ฏ๋ก, ๋์ด๋ฅผ ํ์นธ์ฉ ์ค์ฌ๊ฐ๋ฉด์ ์๊ทผ์ด๊ฐ M๋ฏธํฐ์ ๋๋ฌด๋ฅผ ๊ฐ์ ธ๊ฐ ์ ์๋์ง ํ์ธํ๋ค๋ฉด ๋์ ํ๋ฅ ๋ก ์๊ฐ ์ด๊ณผ๊ฐ ๋ ๊ฒ์ด๋ค. ๋ฐ๋ผ์, ๋ชฉ์ ์ ๋จ๊ธฐ ๋์ด ๋ฒ์๋ฅผ [0 ~ ๋๋ฌด๋ค ์ค ์ต๋ ๋์ด]๋ก ์ค์ ํ๊ณ , ์ด๋ถํ์์ ์ํํด์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๋์ด์ ์ต๋๊ฐ์ ์ฐพ๋ ๊ฒ์ด ์ณ์ ํ๋จ์ผ ๊ฒ์ด๋ค.
์ด๋ถ ํ์์ ์ํํ๋๋ฐ O(log(๋๋ฌด ๋์ด์ ๋ฒ์))์ ์๊ฐ๋ณต์ก๋๊ฐ ์์๋๊ณ , ๊ฐ ๋์ด์ ๋ํด ๋๋ฌด๊ฐ ์ผ๋ง๋ ์ ๋จ๋๋์ง ํ์ธํด์ผํ๋ฏ๋ก N๊ฐ์ ๋๋ฌด๋ฅผ ์ํํด์ผํด์ O(N)์ ์๊ฐ์ด ์์๋๋ค. ์ฆ, ์ต์ข ์๊ฐ๋ณต์ก๋๋ O(Nlog(๋๋ฌด ๋์ด์ ๋ฒ์))๊ฐ ๋๋ฏ๋ก ์๊ฐ ๋ด์ ์ถฉ๋ถํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ค.
๐ ์ฝ๋ ์ค๊ณํ๊ธฐ
- ๋๋ฌด์ ์ N, ๋๋ฌด์ ๊ธธ์ด M ์ ๋ ฅ๋ฐ๊ธฐ
- ๋๋ฌด๋ค์ ๋์ด trees ๋ฆฌ์คํธ๋ก ์ ๋ ฅ๋ฐ๊ธฐ
- low๋ฅผ 0, high๋ฅผ ์ ๋ ฅ๋ฐ์ ๋๋ฌด ๋์ด ์ค ๊ฐ์ฅ ํฐ ๊ฐ์ผ๋ก ์ค์ ํ๊ณ ์ด๋ถํ์ ์ํ
- ๊ฐ ํ์ ๊ณผ์ ์์ mid=(low+high)//2๊ฐ ํด๋น ๊ณผ์ ์ ์ ๋จ๊ธฐ ๋์ด๊ฐ ๋๊ณ , trees๋ฅผ ์ํํ๋ฉฐ ์ด ๊ฐ์ ธ๊ฐ ์ ์๋ ๋๋ฌด ๊ธธ์ด tree_length ๊ตฌํ๊ธฐ
- tree_length๊ฐ M๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๋ค๋ฉด, ์ ๋ต ํ๋ณด์ด๋ฏ๋ก result์ mid๊ฐ์ ์ ์ฅ ํ ๋ ํฐ ๊ฐ์ด ๊ฐ๋ฅํ์ง ํ์ธํ๊ธฐ ์ํด low๋ฅผ mid+1๋ก ๋ณ๊ฒฝํ๊ณ , ์๋๋ผ๋ฉด high๋ฅผ mid-1๋ก ๋ณ๊ฒฝํ๋ค.
- low๊ฐ high๋ฅผ ๋์ ๋๊น์ง ๋ฐ๋ณตํ๊ณ ๊ทธ๋์ result ๊ฐ์ ์ถ๋ ฅํ๋ค.
๐ ์ ๋ต ์ฝ๋
N, M = map(int, input().split())
trees = list(map(int, input().split()))
low = 0
high = max(trees)
result = 0
while low <= high:
mid = (low + high) // 2
tree_length = 0
for tree in trees:
if tree > mid:
tree_length += tree - mid
if tree_length >= M:
result = mid
low = mid+1
else:
high = mid-1
print(result)