1. ๋ฌธ์ ์ค๋ช ๐
2. ์ ๊ทผ ๋ฐฉ์ ๐๏ธ
KEY WORD
: Binary Search
, Parametric Search
, Greedy Algorithm
- (1) ์ง ๊ฐ์ ์ต์ ๊ฑฐ๋ฆฌ์ ์ต๋๊ฑฐ๋ฆฌ๋ฅผ ํ์ฉํด, ์์์ ๊ฑฐ๋ฆฌ
d
๋ฅผ ์ฐ์ ํ๋ค. - (2) '๋ชจ๋ ๊ณต์ ๊ธฐ ์ฌ์ด์ ๊ฑฐ๋ฆฌ๊ฐ ์ต์ํ d ์ด์์ธ๊ฐ?'๋ฅผ boolean ๊ฐ์ผ๋ก ๊ณ์ฐํ๋ค.
- (3) (2)๋ฒ์ด true๋ฉด,
start = mid + 1
๋ก ๊ฑฐ๋ฆฌ๋ฅผ ์ํฅ ์กฐ์ , false๋ฉดend = mid - 1
๋ก ํํฅ ์กฐ์ ํ๋ค. - (4) start์ end๊ฐ ์๊ฐ๋ ธ์ ๋,
start - 1
์ด ๋ต์ด๋ค.
(1) Parametric Search ์ด์ฉ
ํด๋น ๋ฌธ์ ๋ ๊ฐ์ฅ ์ธ์ ํ ๋ ๊ณต์ ๊ธฐ ์ฌ์ด์ ์ต๋ ๊ฑฐ๋ฆฌ ์ฆ ์ต์๊ฐ ์ค์์ ์ต๋๊ฐ
์ ๊ตฌํ๋ ์ต์ ํ ๋ฌธ์
์ด๋ค. ์ต์ ํ ๋ฌธ์ ๋ ๋ฐ๋ก ํ๊ธฐ ์ด๋ ต๊ธฐ ๋๋ฌธ์, ์ฌ๋ฌ๊ฐ์ ๊ฒฐ์ ๋ฌธ์
๋ก ๋ณํํ๋ค. ์ฌ๊ธฐ์๋
์ต์ ํ ๋ฌธ์ | ๊ฒฐ์ ๋ฌธ์ |
---|---|
๋์ฌ ์ ์๋ ์ต์ ๊ฑฐ๋ฆฌ ์ฌ์ด์์ ์ต๋๊ฐ ๊ตฌํ๊ธฐ | ๋ ์ธ์ ํ ๊ณต์ ๊ธฐ ์ฌ์ด์ ์ต์ ๊ฑฐ๋ฆฌ๋ฅผ d ๋ก ๋์์ ๋, ๋ชจ๋ ๊ณต์ ๊ธฐ ์ฌ์ด์์ d ์ด์์ด ๋ง์กฑํ๋๊ฐ? |
๋ก ๋ฐ๊พผ๋ค.
์ด๋ฌ๋ฉด f(d) = true ์ค์์ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ์ ์๋ ๊ฐ์ ๊ตฌํ๋ฉด, ๊ทธ๋์ d๊ฐ ์ฐ๋ฆฌ๊ฐ ๋ฐ๋ผ๋ ๋ ๊ณต์ ๊ธฐ ์ฌ์ด์์ ๋ ์ ์๋ ์ต๋ ๊ฑฐ๋ฆฌ์ด๋ค.
(2) f(d)๋ฅผ ๊ตฌํ๋ ๋ฒ Greedy Algorithm
์ต๋ ๊ฑฐ๋ฆฌ ์ฐ์ ์ ์ํด์๋ ์ต๋ํ ์ผ์ชฝ์ ์๋ ์ง๋ถํฐ ์ ํํด ์ฌ์ฉํด์ผ ํ๋ค. ๊ทธ๋์ผ ๋ค์ ๊ณต์ ๊ธฐ๋ฅผ ์ค์นํ ์ฅ์์ ๊ฑฐ๋ฆฌ๋ฅผ ์ต๋ํ ํฌ๊ฒ ๋ง๋ค ์ ์๊ธฐ ๋๋ฌธ์ด๋ค.
๋ถ๋ถ์ ์ธ ์ต์ ์ ํด๋ต์ด ๊ณง ์ ์ฒด์ ์ต์ ์ ํด๊ฐ ๋๋ฏ๋ก, Greedy Algorithm
์ด ์ฑ๋ฆฝํ๋ค.
3. ์ฝ๋ ์๊ฐ ๐
import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Main {
static int N, C; // ๊ฐ๊ฐ ์ง์ ๊ฐ์,๊ณต์ ๊ธฐ ๊ฐ์
static int [] homes; // ์ง์ ์ขํ๋ค
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());
homes = new int [N];
for (int i = 0; i < N; i++) {
homes[i] = Integer.parseInt(br.readLine());
}
Arrays.sort(homes);
System.out.println(binary_search());
}
public static int binary_search(){
int start = 0;
int end = 1000000001;
while (start <= end) {
int mid = start + (end - start)/2;
if(f(mid)) start = mid + 1;
else end = mid - 1;
}
return start - 1;
}
public static boolean f(int d) {
int router_cnt = C - 1;
int prev_router_loc = homes[0];
for (int i = 1; i < N; i++) {
if(homes[i] - prev_router_loc < d) continue;
prev_router_loc = homes[i];
router_cnt--;
if(router_cnt == 0) {
return true;
}
}
return false;
}
}
4. ๋ฐฐ์ด ๊ฒ๋ค ๐ฏ
Parametric Search ๋ฐฉ๋ฒ์ด ์ด๋ถ ํ์ ๋ฌธ์ ์ ํ์์ ๋น์ถ๋จ์ ๊นจ๋ฌ์๋ค.