๋ฌธ์
ํด๋น ํฌ์คํ ์ ๋ฐฑ์ค์ 2805๋ฒ ๋๋ฌด ์๋ฅด๊ธฐ ์ ์ ๊ทผ๊ณผ ํด๊ฒฐ ๋ฐฉ๋ฒ์ ์ค๋ช ํ ๊ธ ์ ๋๋ค.
์ ๋ต ์์ค ์ฝ๋๋ฅผ ํ์ธํ์๋ ค๋ฉด solve url ์์ ํ์ธ ๊ฐ๋ฅํฉ๋๋ค.
์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์ด๋ค ๋ฐฉ์์ผ๋ก ์ ๊ทผํด์ผ ํ๋์ง๋ฅผ ๋จผ์ ์๊ฐํด๋ณด์.
๋ฌธ์ ์ ๊ทผ
์ด ๋ฌธ์ ๋ ์ง๋ ๋์ ์๋ฅด๊ธฐ ๋ฌธ์ ์ ๋น์ทํ ๋ฐฉ๋ฒ์ผ๋ก ํด๊ฒฐํ ์ ์๋ค.
์ฐ์ ๋ฌธ์ ๋ฅผ ์ฝ๊ณ ์ด๋ค ๊ฒ์ ์ํ๋์ง ํ์
๋ถํฐ ํด๋ณด์.
์ฐ๋ฆฌ์๊ฒ ๋๋ฌด์ ์ N๊ณผ ๊ทธ์ ๋ฐ๋ฅธ ๋๋ฌด๋ค์ ๋์ด๊ฐ ์ฃผ์ด์ง๋ค.
๊ทธ๋ฆฌ๊ณ ์๊ทผ์ด๊ฐ ์ง์ ๊ฐ์ ธ๊ฐ์ผ ํ ๋๋ฌด์ ๋์ด๋ํ ์ฃผ์ด์ง๋ค.
๊ทธ๋ผ ์ด๋ฅผ ํ ๋ฌธ์ฅ์ผ๋ก ์ ๋ฆฌํด๋ณด์.
๋๋ฌด์ ์ N๊ณผ ๊ฐ๊ฐ์ ๋๋ฌด ๋์ด์ ์๊ทผ์ด๊ฐ ํ์ํ ๋๋ฌด์ ๋์ด M์ด ์ฃผ์ด์ง๊ณ M์ด ์ต์๊ฐ ๋๋ ์ ๋จ๊ธฐ ๋์ด๋ฅผ ๊ตฌํ๋ผ.
๊ทธ๋ผ ์ ๋จ๊ธฐ ๋์ด๋ฅผ 1 ~ ๋๋ฌด ์ต๋ ๋์ด์ธ 20์ต
๊น์ง ์ค์ ํด์ ํ์ํ๊ณ , m์ด ๋๋ ์ต์์ ์ ๋จ๊ธฐ ๋์ด๋ฅผ ๊ตฌํ๋ฉด ๋์ง ์์๊น?
์ด ์์ ํ์์ด ๊ฐ๋ฅํ๋ ค๋ฉด ํ๋์ ์ ์ ์กฐ๊ฑด์ด ํ์ํ๋ค.
๋ฐ๋ก ์ต์ ์ ๊ฒฝ์ฐ์๊ฐ ๋ณต์ก๋๊ฐ ํต๊ณผ ํ ๊ฒ์ธ์ง.
๋๋ฌด์ ๋์ด๋ 10์ต์ด๋ค.
๊ทธ๋ผ ์ต์ ์ ๊ฒฝ์ฐ ๋๋ฌด์ ๋์ด๊ฐ 10์ต ์ผ ๋, ์ ๋จ๊ธฐ ๋์ด๋ฅผ 1๋ถํฐ ์ถ๋ฐํ๋ค๋ฉด 10์ต๋ฒ ๋ฐ๋ณต์ ๋์์ผ ํ๋ฏ๋ก ์ ๋ ์ ํ ์๊ฐ ๋ด์ ํต๊ณผํ ์ ์๋ค.
๊ทธ๋ผ ์ฌ๊ธฐ์ ๋ ์๊ฐํ ์ ์๋ ๊ฒ์ ๋ฐ๋ก ์ด๋ถ ํ์ ์๊ณ ๋ฆฌ์ฆ์ด๋ค.
ํด๊ฒฐ๋ฒ
์ด๋ถ ํ์์ ํ๊ธฐ ์ํด์ ํ์ ์กฐ๊ฑด์ ํ์ธํด๋ณด์.
์ฐ์ ์ฐ๋ฆฌ๊ฐ ์ฐพ์์ผ ํ๋ ๊ฒ์ ์ ๋จ๊ธฐ์ ๋์ด์ด๋ค.
์ ๋จ๊ธฐ์ ๋์ด๋ 1 ~ 20์ต๊น์ง ์ด๋ฏ๋ก 1 ๋ถํฐ 20์ต ๊น์ง ์ด๋ถ ํ์์ ํตํด์ ๋ต์ ์ฐพ์๋๊ฐ ๊ฒ์ด๋ค.
ํ์์ start์ end๋ฅผ mid๋ก ๊ฐ๊ฐ ๋๋ 2๊ฐ์ง ์กฐ๊ฑด์ ์๊ฐํด๋ณด์.
- ์๋ฅธ ๋๋ฌด์ ์ด ํฉ์ด n๋ณด๋ค ํด ๋ :
count >= m
์ธ ๊ฒฝ์ฐ๋ ๋๋ฌด๊ฐ ๋ ํฌ๊ฒ ์๋ ค์ผ ํ๊ธฐ ๋๋ฌธ์ start๋ฅผ mid + 1 ํด์ค๋ค. - ์๋ฅธ ๋๋ฌด์ ์ด ํฉ์ด n๋ณด๋ค ์์ ๋ :
count < m
์ธ ๊ฒฝ์ฐ๋ ๋๋ฌด๊ฑฐ ๋ ์๊ฒ ์๋ผ์ผ ํ๊ธฐ ๋๋ฌธ์ start๋ฅผ mid - 1 ํด์ค๋ค.
์ค๋ต ํ๋ณด
์ด๋ฒ์๋ ์ญ์ count์ mid ๊ฐ์ Integer Overflow ์๋ฌ๋ฅผ ์ฃผ์ํด์ค์ผ ํ๋ค.
๊ทธ๋์ intํ์ ๋ฒ์ด๋ ๋ณ์๋ค์ long์ผ๋ก ํ ๋นํด์ฃผ์.
์ ๋ต ์ฝ๋
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
String[] nm = br.readLine().split(" ");
int n = Integer.parseInt(nm[0]);
int m = Integer.parseInt(nm[1]);
long[] arr = new long[n];
String[] trees = br.readLine().split(" ");
long max = 0;
for (int i = 0; i < trees.length; i++) {
arr[i] = Long.parseLong(trees[i]);
max = Math.max(max, arr[i]);
}
long start = 1;
long end = 1_000_000_000;
long answer = 0;
while(start <= end) {
long mid = start + (end - start) / 2;
long count = 0;
for(long value : arr) {
if(value - mid > 0) {
count += Math.abs(value - mid);
}
}
if(count >= m) {
answer = Math.max(answer, mid);
start = mid + 1;
}else {
end = mid - 1;
}
}
bw.write(String.valueOf(answer));
bw.flush();
bw.close();
}
}
๋ฌธ์ ํ๊ณ
์ด๋ฒ ๋ฌธ์ ์์๋ ์ ๋จ๊ธฐ์ ์ต๋ ๋์ด๋ฅผ ์ ๋ ฅ๋ฐ์ ๋๋ฌด๋ค์ ์ต๋ ๋์ด๋ก ์ค์ ํด๋ฒ๋ ค์ 2๋ฒ์ด๋ ํ๋ ธ๋ ๋ฌธ์ ์ด๋ค.
์ ๋จ๊ธฐ์ ์ต๋ ๋์ด์ ๋๋ฌด๋ค์ ์ต๋ ๋์ด์๋ ์ ํ์๊ด์ด ์๋ค.
์ ๋ด๊ฐ ๋๋ฌด ์ต๋ ๋์ด๊ฐ ์๊ด์ด ์๋๊ณ ์๊ฐํ๋๋ฉด, ์ง๋ ๋์ ์๋ฅด๊ธฐ์์ ์๋ฅด๋ ๋์ ์ ๊ธธ์ด์ ์ต๋๋ฅผ ์ ๋ ฅ๋ฐ์ ๋์ ์ ์ต๋ ๊ธธ์ด๋ก ์ค์ ํ๊ธฐ ๋๋ฌธ์ด๋ค.
์ง๋๋ฒ์๋ ์ ๋ ฅ๋ฐ์ ๋์ ์ ์ต๋ ๊ธธ์ด๊ฐ ์๋ฅด๋ ๋์ ์ ๊ธธ์ด๋ณด๋ค ์์ ์ ์๊ธฐ ๋๋ฌธ์ด์๋ค.
ํ์ง๋ง ์ง๊ธ์ ๋๋ฌด๊ฐ ๋ ๋์ด๊ฐ ๊ธธ ์๋ ์๊ณ , ์๋ผ์ผ ํ๋ ์ ๋จ๊ธฐ๊ฐ ๋ ๋์์ผํ ์ ์๊ธฐ ๋๋ฌธ์ ์ค์ ์ ์ ํด์ค์ผ ํ๋ค.
๋๊ธ