[๊ฒฐ์ ์๊ณ ๋ฆฌ์ฆ] 10.๋ง๊ตฌ๊ฐ ์ ํ๊ธฐ
<<ํ์ด>>
๊ฒฐ์ ์๊ณ ๋ฆฌ์ฆ์ ํ์ฉํด์ ๋ฌธ์ ๋ฅผ ํ์๋ค.
์ด ๋ฒ ๋ฌธ์ ๋ ๊ฑฐ๋ฆฌ์ ๋ํด ๊ฐ์ฅ ์์ ๊ฑฐ๋ฆฌ 1๊ณผ ์ต๋ ๊ฑฐ๋ฆฌ 9๋ฅผ lt์ rt๋ก ๋๊ณ , mid = (lt + rt) / 2๋ฅผ ํ์ฉํ๋ค.
1 ์์ 9 ์ฌ์ด์ ์ ๋ต์ด ๋ฌด์กฐ๊ฑด ์๋ค๋ ์ ์ ๊ฐ ๊น๋ ค์๊ธฐ ๋๋ฌธ์ด๋ค.
์ด์ ๊ตฌํ mid๋ก ์ค์ ๊ฑฐ๋ฆฌ๋ฅผ ๋นผ๊ฐ๋ฉด์ ๋น๊ตํ๋๋ฐ, ์ฐ์ ๊ฐ์ฅ ์ฒซ๋ฒ์งธ 1 ์์น์ ๋ง์ ๋๊ณ ์์ํ๋ค. 1์ ๋๊ณ ์์ํด์ผ ๊ณต๊ฐํ๋ณด์ ์ ๋ฆฌํ๊ธฐ ๋๋ฌธ์ด๋ค. ๊ทธ๋ค์ mid ๋ณด๋ค ๊ฐ๊ฑฐ๋ ํฌ๋ฉด ์ค์งํ๊ณ ๊ทธ ์์น์ ๋ง์ ๋๋ค. ๊ทธ๋ฆฌ๊ณ 1 ์์น์์ ๋ถํฐ ๊ฑฐ๋ฆฌ๋ฅผ ๊ตฌํ๋ ๊ฒ์ ๋ง์ ๋ ์์น๋ก ๋ณ๊ฒฝํ ๋ค ๊ฐ์ ์์ ์ ๋ฐ๋ณตํ๋ค.
๊ทธ๋ ๊ฒ ํด์ ๋์จ ๊ฐ์ด ๋ฃ์ ์ ์๋ ๋ง์ด ์ค์ ๋ฃ์ผ๋ ค๋ ๋ง์ ์ ๋ณด๋ค ๊ฐ๊ฑฐ๋ ํฌ๋ฉด ๊ทธ ๊ฐ์ ์ ๋ ฅํ ํ๋ณด๊ฐ ๋๋ค.
๋ง์ฝ ํฌ๊ฑฐ๋ ๊ฐ๋ค๋ฉด, mid ์ดํ์ ๊ฐ์ ๋ฌด์กฐ๊ฑด ๋๊ธฐ ๋๋ฌธ์ mid ์๋๋ ๋ฌด์ํ๋ค. ๊ทธ๋์ lt๋ฅผ mid + 1๋ก ๋ค์ ์ด๊ธฐํ ์ํจ๋ค.
์ด ๊ณผ์ ์ lt > rt ๋๊ธฐ ์ ๊น์ง ์งํํ๋ค.
์ด ์๊ณ ๋ฆฌ์ฆ์ ํต์ฌ์ ์ ๋ ฌ๋ ๊ฐ๊ณผ ๊ทธ ์ ๋ ฌ๋ ๊ฐ ์์ ๋ฌด์กฐ๊ฑด ๋ต์ด ์์ ๋ ์ฌ์ฉ์ด ๊ฐ๋ฅํ๋ค !! ์ด์ ์ ์ ๊ธฐ์ตํด๋ฌ์ ๋์ค์ ๋ ์จ๋จน์ ใ ใ
import java.util.Arrays;
import java.util.Scanner;
class Main{
private int total(int[] arr, int mid) {
int em = arr[0];
int count = 1;
for(int i = 1; i < arr.length; i++) {
if(arr[i] - em >= mid) {
count++;
em = arr[i];
}
}
return count;
}
private int solution(int n, int m, int[] arr) {
Arrays.sort(arr);
int rt = Arrays.stream(arr).max().getAsInt();
int lt = Arrays.stream(arr).min().getAsInt();
int answer = 0;
while(lt <= rt) {
int mid = (rt + lt) / 2;
if(total(arr, mid) >= m) {
answer = mid;
lt = mid + 1;
} else rt = mid - 1;
}
return answer;
}
public static void main(String[] args) {
Main T = new Main();
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int m = in.nextInt();
int[] arr = new int[n];
for(int i = 0; i < n; i++) {
arr[i] = in.nextInt();
}
System.out.println(T.solution(n, m, arr));
}
}
'์ฝ๋ฉํ ์คํธ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์ฌ๊ทํจ์] 2. ์ด์ง์ ์ถ๋ ฅ (1) | 2024.01.26 |
---|---|
[์ฌ๊ทํจ์] ์ฌ๊ทํจ์ (1) | 2024.01.26 |
[๊ฒฐ์ ์๊ณ ๋ฆฌ์ฆ] 9. ๋ฎค์ง๋น๋์ค (1) | 2024.01.24 |
[์ ๋ ฌ] 8. ์ด๋ถ๊ฒ์ (0) | 2024.01.20 |
[์ ๋ ฌ] 7. ์ขํ ์ ๋ ฌ (0) | 2024.01.20 |
๋๊ธ