[BOJ] 2110 ๊ณต์ ๊ธฐ ์ค์น_JAVA
[ ๋ฌธ์ ]
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)๊ฐ ํ ์ค์ ํ๋์ฉ ์ฃผ์ด์ง๋ค.
[ ์ถ๋ ฅ ]
์ฒซ์งธ ์ค์ ๊ฐ์ฅ ์ธ์ ํ ๋ ๊ณต์ ๊ธฐ ์ฌ์ด์ ์ต๋ ๊ฑฐ๋ฆฌ๋ฅผ ์ถ๋ ฅํ๋ค.
[Solution 1]
- ๊ฒฐ๊ณผ๋ ๋ง์ง๋ง ์๊ฐ์ด๊ณผ
- ์
๋ ฅ์กฐ๊ฑด์ด ‘2 ≤ N ≤ 200,000’ ‘0 ≤ xi ≤ 1,000,000,000’์ธ๋ฐ ๋น์ฐ์ฐ...
- ์ด๋ ๊ฒ ๋ง๋์๋๋ max๊ฐ์ด ์ฃผ์ด์ง๋ค๋ฉด ์ด์งํ์์ผ๋ก ์ ๊ทผํด๋ณด๊ธฐ
package boj2110_๊ณต์ ๊ธฐ์ค์น;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Collections;
import java.util.PriorityQueue;
import java.util.StringTokenizer;
public class Main {
static int c, n;
static int[] combi;
static int [] hp;
static PriorityQueue<Integer> minArr = new PriorityQueue<Integer>(Collections.reverseOrder());
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()); //๊ณต์ ๊ธฐ ๊ฐ์
hp = new int[n];
combi = new int[c];
for(int i=0; i<n; i++) {
st = new StringTokenizer(br.readLine());
hp[i] = Integer.parseInt(st.nextToken());
}
Arrays.sort(hp);
combination(0, 0);
System.out.println("RESULT : " + minArr.poll());
}
static void combination(int r, int start) {
if(r == c) {
int min = hp[n-1];
for(int i=0; i<c-1; i++) {
if(i+1 < c) {
min = Math.min(min, combi[i+1] - combi[i]);
}
}
minArr.add(min);
return;
}
for(int i=start; i<n; i++) {
combi[r] = hp[i];
combination(r+1, i+1);
}
}
}
[Solution 2]
- ์ด์งํ์
package boj2110_๊ณต์ ๊ธฐ์ค์น;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Main2 {
static int c, n;
static int [] hp;
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()); //๊ณต์ ๊ธฐ ๊ฐ์
hp = new int[n];
for(int i=0; i<n; i++) {
st = new StringTokenizer(br.readLine());
hp[i] = Integer.parseInt(st.nextToken());
}
Arrays.sort(hp);
int min = 1; //๊ณต์ ๊ธฐ๊ฐ ์ต์๊ฑฐ๋ฆฌ
int max = hp[n-1] - 1; //๊ณต์ ๊ธฐ ๊ฐ ์ต๋๊ฑฐ๋ฆฌ
int answer = 0;
while(min <= max) {
int middle = (max+min)/2; //๊ณต์ ๊ธฐ ๊ฑฐ๋ฆฌ ๊ธฐ์ค
int prev = hp[0]; //์ฒซ ์์น ์ค์น
int cnt = 1; //์ค์นํ ๊ณต์ ๊ธฐ ์
for(int i=0; i<n; i++) {
int distance = hp[i] - prev; //๊ฑฐ๋ฆฌ์ฐจ
if(distance >= middle) { //๊ฑฐ๋ฆฌ์ฐจ๊ฐ ๊ธฐ์ค๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์์ผ ์ค์น ๊ฐ๋ฅ
cnt++;
prev = hp[i];
}
}
//๊ณต์ ๊ธฐ ์ค์น๊ฐ c๋ณด๋ค ๋ ๋ง์ผ๋ฉด ๊ฐ๊ฒฉ์ ๋ํ์ ๊ฐ์๋ฅผ ์ค์
if(cnt >= c) {
min = middle + 1;
answer = middle;
} else {
max = middle - 1;
}
}
System.out.println(answer);
}
}