๋๋ฌด ์๋ฅด๊ธฐ (๋ฌธ์ _ 2805)
์๊ทผ์ด๋ ๋๋ฌด M๋ฏธํฐ๊ฐ ํ์ํ๋ค. ๊ทผ์ฒ์ ๋๋ฌด๋ฅผ ๊ตฌ์ ํ ๊ณณ์ด ๋ชจ๋ ๋งํด๋ฒ๋ ธ๊ธฐ ๋๋ฌธ์, ์ ๋ถ์ ๋ฒ๋ชฉ ํ๊ฐ๋ฅผ ์์ฒญํ๋ค. ์ ๋ถ๋ ์๊ทผ์ด๋ค ์ง ๊ทผ์ฒ์ ๋๋ฌด ํ ์ค์ ๋ํ ๋ฒ๋ชฉ ํ๊ฐ๋ฅผ ๋ด์ฃผ์๊ณ , ์๊ทผ์ด๋ ์๋ก ๊ตฌ์ ํ ๋ชฉ์ฌ์ ๋จ๊ธฐ๋ฅผ ์ด์ฉํด์ ๋๋ฌด๋ฅผ ๊ตฌํ ๊ฒ์ด๋ค.
๋ชฉ์ฌ์ ๋จ๊ธฐ๋ ๋ค์๊ณผ ๊ฐ์ด ๋์ํ๋ค. ๋จผ์ , ์๊ทผ์ด๋ ์ ๋จ๊ธฐ์ ๋์ด H๋ฅผ ์ง์ ํด์ผ ํ๋ค. ๋์ด๋ฅผ ์ง์ ํ๋ฉด ํฑ๋ ์ด ๋ ์ผ๋ก๋ถํฐ H๋ฏธํฐ ์๋ก ์ฌ๋ผ๊ฐ๋ค. ๊ทธ ๋ค์, ํ ์ค์ ์ฐ์ํด์๋ ๋๋ฌด๋ฅผ ๋ชจ๋ ์ ๋จํด๋ฒ๋ฆฐ๋ค. ๋ฐ๋ผ์, ๋์ด๊ฐ H๋ณด๋ค ํฐ ๋๋ฌด๋ H ์์ ๋ถ๋ถ์ด ์๋ฆด ๊ฒ์ด๊ณ , ๋ฎ์ ๋๋ฌด๋ ์๋ฆฌ์ง ์์ ๊ฒ์ด๋ค. ์๋ฅผ ๋ค์ด, ํ ์ค์ ์ฐ์ํด์๋ ๋๋ฌด์ ๋์ด๊ฐ 20, 15, 10, 17์ด๋ผ๊ณ ํ์. ์๊ทผ์ด๊ฐ ๋์ด๋ฅผ 15๋ก ์ง์ ํ๋ค๋ฉด, ๋๋ฌด๋ฅผ ์๋ฅธ ๋ค์ ๋์ด๋ 15, 15, 10, 15๊ฐ ๋ ๊ฒ์ด๊ณ , ์๊ทผ์ด๋ ๊ธธ์ด๊ฐ 5์ธ ๋๋ฌด์ 2์ธ ๋๋ฌด๋ฅผ ๋ค๊ณ ์ง์ ๊ฐ ๊ฒ์ด๋ค. (์ด 7๋ฏธํฐ๋ฅผ ์ง์ ๋ค๊ณ ๊ฐ๋ค)
์๊ทผ์ด๋ ํ๊ฒฝ์ ๋งค์ฐ ๊ด์ฌ์ด ๋ง๊ธฐ ๋๋ฌธ์, ๋๋ฌด๋ฅผ ํ์ํ ๋งํผ๋ง ์ง์ผ๋ก ๊ฐ์ ธ๊ฐ๋ ค๊ณ ํ๋ค. ์ด๋, ์ ์ด๋ M๋ฏธํฐ์ ๋๋ฌด๋ฅผ ์ง์ ๊ฐ์ ธ๊ฐ๊ธฐ ์ํด์ ์ ๋จ๊ธฐ์ ์ค์ ํ ์ ์๋ ๋์ด์ ์ต๋๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์
๋ ฅ
์ฒซ์งธ ์ค์ ๋๋ฌด์ ์ N๊ณผ ์๊ทผ์ด๊ฐ ์ง์ผ๋ก ๊ฐ์ ธ๊ฐ๋ ค๊ณ ํ๋ ๋๋ฌด์ ๊ธธ์ด M์ด ์ฃผ์ด์ง๋ค. (1 ≤ N ≤ 1,000,000, 1 ≤ M ≤ 2,000,000,000)
๋์งธ ์ค์๋ ๋๋ฌด์ ๋์ด๊ฐ ์ฃผ์ด์ง๋ค. ๋๋ฌด์ ๋์ด์ ํฉ์ ํญ์ M์ ๋๊ธฐ ๋๋ฌธ์, ์๊ทผ์ด๋ ์ง์ ํ์ํ ๋๋ฌด๋ฅผ ํญ์ ๊ฐ์ ธ๊ฐ ์ ์๋ค. ๋์ด๋ 1,000,000,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ ์ ์ ๋๋ 0์ด๋ค.
์ถ๋ ฅ
์ ์ด๋ M๋ฏธํฐ์ ๋๋ฌด๋ฅผ ์ง์ ๊ฐ์ ธ๊ฐ๊ธฐ ์ํด์ ์ ๋จ๊ธฐ์ ์ค์ ํ ์ ์๋ ๋์ด์ ์ต๋๊ฐ์ ์ถ๋ ฅํ๋ค.
์์
4 7
20 15 10 17
< answer > 15
ํ์ด
n์ ํฌ๊ธฐ๊ฐ ๋งค์ฐ ํฌ๊ธฐ ๋๋ฌธ์ binarySearch๋ฅผ ์ฌ์ฉํ๋ค.
๋์ด h๋ 0๋ถํฐ ๊ฐ์ฅ ๋์ ๋๋ฌด์ ๋์ด๊ฐ ๋ ์ ์๋ค.
๋์ด๋ฅผ 0์ผ๋ก ์ค์ ํ๋ฉด ๋๋ฌด์ ์ ์ฒด ๋์ด๋งํผ ์๋ฅผ ์ ์๊ฒ ๋๊ณ , ๊ฐ์ฅ ๋์ ๋๋ฌด์ ๋์ด(maxH)๊ฐ ๋๋ค๋ฉด 0๋ฏธํฐ์ ๋๋ฌด๋ฅผ ๊ฐ์ ธ๊ฐ๋ค.
์ฒ์์ผ๋ก ์ค์ ํ h๋ฅผ (maxH+0) / 2๋ก ์ค์ ํ๊ณ ๋๋ฌด๋ฅผ ์๋์ ๋์ ์ป์ ์ ์๋ ๋๋ฌดํ ๋ง์ ๊ธธ์ด๋ฅผ ํ๋จํ๋ค.
๊ฐ์ ธ๊ฐ์ผํ๋ ๋๋ฌด๋ณด๋ค ๊ธธ์ด๊ฐ ์์๊ฒฝ์ฐ
์ ๋จ๊ธฐ์ ๋์ด๋ฅผ ๋ ์๊ฒ ์กฐ์ ํด์ ๋ค์ ๋๋ฌด๋ฅผ ์๋ฅธ๋ค
๊ฐ์ ธ๊ฐ์ผํ๋ ๋๋ฌด๋ณด๋ค ๊ธธ์ด๊ฐ ๊ธด ๊ฒฝ์ฐ
์ด๋๋ก ๋๋ฌด๋ฅผ ์ ๋จํด๋ ๋์ง๋ง ์ฐ๋ฆฌ๋ ๋์ด์ ์ต๋๊ฐ์ ์ํ๊ธฐ ๋๋ฌธ์ ๋์ด๋ฅผ ์ข ๋ ๋๊ฒํด์ ๋ค์ ๋๋ฌด๋ฅผ ์๋ฅธ๋ค
while๋ฌธ์ด ๋๋๋ค๋ฉด ๊ทธ ๋น์์ ๋์ด ๊ฐ์ด ์ต๋๋์ด๊ฐ ๋๋ค.
์ฝ๋
int start = 0, end = 0;
for (int i = 0; i < n; i++) {
arr[i] = Integer.parseInt(st.nextToken());
end = Math.max(arr[i], end); // ๊ฐ์ฅ ๊ธด ๋๋ฌด์ ๋์ด๋ฅผ ๊ตฌํ๋ค
} // end of input
int mid = 0;
long sum = 0;
int ans = 0;
while(start <= end) {
mid = (start+end) / 2;
sum = 0;
for (int i = 0; i < n; i++) {
if(arr[i] >= mid) sum += (arr[i]- mid);
} // ๋๋ฌด ์๋ฅด๊ธฐ
if(sum < m) {
end = mid-1; // ๋์ด๋ฅผ ๋ ๋ฎ๊ฒํ๋ค
}
else {
ans = Math.max(ans, mid);
start=mid+1; // ๋์ด๋ฅผ ๋ ๋๊ฒํ๋ค
}
}