๐ ๋ฌธ์
https://www.acmicpc.net/problem/2110
2110๋ฒ: ๊ณต์ ๊ธฐ ์ค์น
์ฒซ์งธ ์ค์ ์ง์ ๊ฐ์ N (2 ≤ N ≤ 200,000)๊ณผ ๊ณต์ ๊ธฐ์ ๊ฐ์ C (2 ≤ C ≤ N)์ด ํ๋ ์ด์์ ๋น ์นธ์ ์ฌ์ด์ ๋๊ณ ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์๋ ์ง์ ์ขํ๋ฅผ ๋ํ๋ด๋ xi (0 ≤ xi ≤ 1,000,000,000)๊ฐ
www.acmicpc.net
๋ฌธ์
๋ํ์ด์ ์ง N๊ฐ๊ฐ ์์ง์ ์์ ์๋ค. ๊ฐ๊ฐ์ ์ง์ ์ขํ๋ x1, ..., xN์ด๊ณ , ์ง ์ฌ๋ฌ๊ฐ๊ฐ ๊ฐ์ ์ขํ๋ฅผ ๊ฐ์ง๋ ์ผ์ ์๋ค.
๋ํ์ด๋ ์ธ์ ์ด๋์๋ ์์ดํ์ด๋ฅผ ์ฆ๊ธฐ๊ธฐ ์ํด์ ์ง์ ๊ณต์ ๊ธฐ C๊ฐ๋ฅผ ์ค์นํ๋ ค๊ณ ํ๋ค. ์ต๋ํ ๋ง์ ๊ณณ์์ ์์ดํ์ด๋ฅผ ์ฌ์ฉํ๋ ค๊ณ ํ๊ธฐ ๋๋ฌธ์, ํ ์ง์๋ ๊ณต์ ๊ธฐ๋ฅผ ํ๋๋ง ์ค์นํ ์ ์๊ณ , ๊ฐ์ฅ ์ธ์ ํ ๋ ๊ณต์ ๊ธฐ ์ฌ์ด์ ๊ฑฐ๋ฆฌ๋ฅผ ๊ฐ๋ฅํ ํฌ๊ฒ ํ์ฌ ์ค์นํ๋ ค๊ณ ํ๋ค.
C๊ฐ์ ๊ณต์ ๊ธฐ๋ฅผ N๊ฐ์ ์ง์ ์ ๋นํ ์ค์นํด์, ๊ฐ์ฅ ์ธ์ ํ ๋ ๊ณต์ ๊ธฐ ์ฌ์ด์ ๊ฑฐ๋ฆฌ๋ฅผ ์ต๋๋ก ํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์ง์ ๊ฐ์ N (2 ≤ N ≤ 200,000)๊ณผ ๊ณต์ ๊ธฐ์ ๊ฐ์ C (2 ≤ C ≤ N)์ด ํ๋ ์ด์์ ๋น ์นธ์ ์ฌ์ด์ ๋๊ณ ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์๋ ์ง์ ์ขํ๋ฅผ ๋ํ๋ด๋ xi (0 ≤ xi ≤ 1,000,000,000)๊ฐ ํ ์ค์ ํ๋์ฉ ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ๊ฐ์ฅ ์ธ์ ํ ๋ ๊ณต์ ๊ธฐ ์ฌ์ด์ ์ต๋ ๊ฑฐ๋ฆฌ๋ฅผ ์ถ๋ ฅํ๋ค.
โ๏ธ ํ์ด
๐ก ์ต๋ํ ๊ฑฐ๋ฆฌ๋ฅผ ๋ฒ๋ ค์ ๊ณต์ ๊ธฐ๋ฅผ ์ค์นํ๋๊ฒ ๋ชฉ์ ์ด๋ค.
๋ฐ๋ผ์ ๊ณต์ ๊ธฐ๋ฅผ ์ค์นํ ๊ฑฐ๋ฆฌ์ ์ต์๊ฐ(mid)์ ์ ํด๋๊ณ , ๊ทธ ์ด์์ด ๋ ๋๋ง ๊ณต์ ๊ธฐ๋ฅผ ์ค์นํ๋ค. ๊ทธ ์ดํ์ ๊ฑฐ๋ฆฌ์์ ์ค์นํ๋ฉด, ์ต๋ํ ๊ฑฐ๋ฆฌ๋ฅผ ๋ฒ๋ฆฌ๊ฒ ๋ค๋ ๋ชฉ์ ์ ์์คํ๋ ๊ฒ์ด๋ค.
์ด๋ฒ ์ด๋ถํ์์์ ์กฐ์ ํ๋ ๊ฒ์ด ๋ฐ๋ก ์ด ์ต์๊ฐ์ด๋ค.
houses = new int[N];
for (int i = 0; i < N; i++) {
houses[i] = Integer.parseInt(br.readLine());
}//input
Arrays.sort(houses);
N๊ฐ์ ์ง์ด ์์นํ ์ขํ๋ฅผ ์ ์ฅํด๋๋ ๋ฐฐ์ด์ ๋ง๋ค๊ณ , ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ค.
๋ฐ๋ผ์ house[0]์ด ์ ์ผ ์ผ์ชฝ์ ์์นํ ์ง, house[N-1]์ด ์ ์ผ ์ค๋ฅธ์ชฝ์ ์์นํ ์ง์ด ๋ ๊ฒ์ด๋ค.
์ฌ๊ธฐ์๋ถํฐ๋ ์ด์ ์ด๋ถํ์์ ์์ํ๋ค.
์ฒ์ mid๊ฐ์ ์ต๋๊ธฐ์ค๊ฑฐ๋ฆฌ๋ก, ๋ง์ ์ ์ฒด ๊ธธ์ด(์ฒซ ๋ฒ์งธ ์ง๊ณผ ๋ง์ง๋ง ์ง ์ฌ์ด์ ๊ฑฐ๋ฆฌ)/2๋ก ์ค์ ํ๋ค.
โ๏ธ ์๋ฅผ ๋ค์ด N=4์ด๊ณ , C=3, ๊ฐ ์ง์ ์์น๊ฐ [10,15,40,50]์ด๋ผ๊ณ ํ ๋๋ฅผ ์๊ฐํด๋ณธ๋ค.
์ฒ์ mid๊ฐ์ ์ฒ์ ์ง๊ณผ ๋ง์ง๋ง ์ง ์ฌ์ด์ ์ค๊ฐ๊ฑฐ๋ฆฌ์ธ (10+50)/2=30์ผ ๊ฒ์ด๋ค.
โป๏ธ ์ฒ์ ๊ณต์ ๊ธฐ ์ค์น ์์น๋ ์ฒซ ๋ฒ์งธ ์ง์ ์์น์ธ 10์ด ๋๋ค.
โป๏ธ ๋ ๋ฒ์งธ ์ง์ธ 15์ ๊ฒฝ์ฐ, ์ด์ ์ง 10๊ณผ์ ๊ฑฐ๋ฆฌ์ฐจ๊ฐ 5๋ฐ์ ๋์ง ์์ผ๋ฏ๋ก ๊ธฐ์ค๊ธธ์ด์ธ 30์ ๋์ง ๋ชปํ์ฌ ๊ณต์ ๊ธฐ๋ฅผ ์ค์นํ์ง ์๋๋ค.
โป๏ธ ์ธ ๋ฒ์งธ ์ง์ธ 40์ ๊ฒฝ์ฐ ์ด์ ์ง 10๊ณผ์ ๊ฑฐ๋ฆฌ์ฐจ๊ฐ 30์ด๋ฏ๋ก ๊ธฐ์ค์ ๋ง์กฑํ์ฌ ๊ณต์ ๊ธฐ๋ฅผ ์ค์นํ ์ ์๋ค. ์ด๋ ๊ธฐ์ค์์น๋ ์๋ก ๊ณต์ ๊ธฐ๋ฅผ ์ค์นํ ์์น์ธ 40์ผ๋ก ์ฎ๊ฒจ๊ฐ๋ค.
โป๏ธ ๋ง์ง๋ง ์ง์ธ 50์ ๊ฒฝ์ฐ ์ด์ ์ง 40๊ณผ์ ๊ฑฐ๋ฆฌ์ฐจ์ด๊ฐ 10๋ฐ์ ๋์ง ์์ผ๋ฏ๋ก ๊ณต์ ๊ธฐ๋ฅผ ์ค์นํ์ง ์๋๋ค.
๊ณต์ ๊ธฐ๋ฅผ ๋ ๊ฐ ์ค์นํ์ผ๋ฏ๋ก ๋ชฉํ๊ฐ 3๋ณด๋ค ๋ชจ์๋ผ๋ค. ์ฆ, ๊ฑฐ๋ฆฌ๋ฅผ ๋๋ฌด ๋ฒ๋ ค์ ์ค์นํ๋ค๋ ๋ป์ด๋ค.
์ด๋ด ๋์๋ ๊ธฐ์ค๊ธธ์ด๋ฅผ ์ขํ์ ๋ค์ ํ์์ ์๋ํด๋ณธ๋ค.
if(cnt>=C) {//์ง ์ฌ์ด ๊ฑฐ๋ฆฌ๋ฅผ ์ ๋นํ ์ค์ ํ์ ๋
result = mid;
//์ต์ ์ ํด๋ฅผ ์ํด ๊ฐ๊ฒฉ์ ๋ ๋ํ๋ณธ๋ค
left = mid+1;
}else {//์ง ์ฌ์ด ๊ฑฐ๋ฆฌ๋ฅผ ๋๋ฌด ๋๊ฒ ์ค์ ํ์ ๋
//๊ฐ๊ฒฉ์ ๋ ์ขํ๋ณธ๋ค.
right = mid-1;
}
๐โ๏ธ ์๊ฒฌ
์ํ์ ์ ํ ๋ชปํ๋ ๋๋ก์๋ mid๊ฐ์ ์กฐ์จํ ๋ ์ left=(mid+1)/ right=(mid-1)๊ฐ์ด ํธ๋ ๊ฒ์ธ์ง ์ดํดํ์ง ๋ชปํ๋ค...
๊ฑฐ๋ฆฌ๋ฅผ ์ขํ๋ ค๋ฉด left+1์ด๋ right-1๋ก ํด๋ ๋์์?
ํ์ง๋ง ์ง์ ์ฐ์ด๋ณด๋ ์ฑ๋ฅ์ ์์ด์ ์ ๋ง ํฐ ์ฐจ์ด๊ฐ ์๊ธด๋ค.
์ด๋ถํ์์ ์์๋ฅผ ์ ํ ์๊ฐํด๋ณด์ง ๋ชปํ๋ค๋ ์ฆ๋ช ....(^^)
์ฐ๋์ฐ๋ ์กฐ์จํ๋ ๊ฒ๋ณด๋ค ์ด๋ถํ์์ผ๋ก ์ฃผ์ด์ง ๊ฐ์์ ํฌ๊ฒํฌ๊ฒ ์ฎ๊ฒจ๊ฐ๋ ๊ฒ์ด ํจ์ฌ ์ฑ๋ฅ์ ์ข๋ค.
๊ทธ๋ฅ ์ธ์ฐ์!!!
๐ป ์์ค์ฝ๋: ์๋ฐ(Java)
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;
// ์ด๋ถํ์, ๋งค๊ฐ ๋ณ์ ํ์
public class Main_๋ฐฑ์ค_2110_๊ณต์ ๊ธฐ์ค์น_๊ณจ๋V {
static int N, C;
static int[] houses;
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
N = Integer.parseInt(st.nextToken());
C = Integer.parseInt(st.nextToken());
houses = new int[N];
for (int i = 0; i < N; i++) {
houses[i] = Integer.parseInt(br.readLine());
}//input
Arrays.sort(houses);
//1.์์ ํ์
/*int max = houses[N-1]-houses[0]; //์ต๋๊ฐ๊ฒฉ
int dist = 1; //์์๊ฐ๊ฒฉ
while(dist<=max) {
// ์ฒซ ๋ฒ์งธ ๊ณต์ ๊ธฐ
int cnt = 1;
int before_pos = houses[0];
// ๊ณต์ ๊ธฐ ์ค์น์์
for (int i = 1; i < N; i++) {
// ๊ฐ๊ฒฉ์ด ๊ณต์ ๊ธฐ๋ฅผ ์ค์นํ ์ ์๋ ์ ๋๋ผ๋ฉด
if(houses[i]-before_pos >= dist) {
cnt++;
before_pos = houses[i];
}
}
if(cnt<C) break;
dist++;
}
System.out.println(dist-1);*/
//2.์ด๋ถํ์
int result = 0;
int left = 0;
int right = houses[N-1]-houses[0]; //์ต๋๊ฐ๊ฒฉ
while(left<=right) {
// ์ฒซ ๋ฒ์งธ ๊ณต์ ๊ธฐ
int cnt = 1;
int before_pos = houses[0];
// ์ง ์ฌ์ด ๊ฑฐ๋ฆฌ -> ์ด๋ถํ์์์ ์กฐ์ ํ ๋ณ์
int mid = (right+left)/2;
// ๊ณต์ ๊ธฐ ์ค์น์์
for (int i = 1; i < N; i++) {
if(houses[i]-before_pos >= mid) {
cnt++;
before_pos = houses[i];
}
}
if(cnt>=C) {//์ง ์ฌ์ด ๊ฑฐ๋ฆฌ๋ฅผ ์ ๋นํ ์ค์ ํ์ ๋
result = mid;
//์ต์ ์ ํด๋ฅผ ์ํด ๊ฐ๊ฒฉ์ ๋ ๋ํ๋ณธ๋ค
left = mid+1;
}else {//์ง ์ฌ์ด ๊ฑฐ๋ฆฌ๋ฅผ ๋๋ฌด ๋๊ฒ ์ค์ ํ์ ๋
//๊ฐ๊ฒฉ์ ๋ ์ขํ๋ณธ๋ค.
right = mid-1;
}
}
System.out.println(result);
}//end of main
}//end of class
๐ ๐ ๐
๏ผฐ๏ฝ๏ฝ๏ฝ๏ฝ ๏ฝ ๏ผข๏ฝ ๏ผณ๏ผก๏ผน
๐๐ฉ๐ข๐ฏ๐ฌ๐ด ๐ง๐ฐ๐ณ ๐ณ๐ฆ๐ข๐ฅ๐ช๐ฏ๐จ