1. ๋ฌธ์ ์ค๋ช ๐
2. ๊ตฌํ ๋ฐฉ๋ฒ ๐๏ธ
KEY WORD
: BINARY_SEARCH
, PARAMETRIC_SEARCH
N
: ๋์ด๊ธฐ๊ตฌ ํ๋ ์์ด ์, M
: ๋์ด๊ธฐ๊ตฌ ์, rids[]
= ๋์ด๊ธฐ๊ตฌ ๋ณ ๊ฑธ๋ฆฌ๋ ์๊ฐ,minimum_time
: ์ ๋ค ์ ๋ถ ๋์ด๊ธฐ๊ตฌ์ ํ์ฐ๋ ์ต์ ์๊ฐ,remained_kid
: (minimum_time
-1 ) ์๊ฐ์ ์์ง ๋์ด๊ธฐ๊ตฌ ๋ชป ํ๊ณ ๋จ์์๋ ์์ด๋ค์ ์
- 0๏ธโฃ
์ฌ๋ ์
<๋์ด๊ธฐ๊ตฌ ์
์ด๋ฉด, ๋ง์ง๋ง ์ฌ๋์ ๋ฒํธ๊ฐ ๊ณง ๋์ด๊ธฐ๊ตฌ์ ์ ์ด๋ฏ๋กN
์ถ๋ ฅ ํ ํ๋ก๊ทธ๋จ ์ข ๋ฃ - 1๏ธโฃ ์์ด๋ค์ ๋ค ํ์ธ ์ ์๋ ์ต์ ์๊ฐ ์ฐพ๊ธฐ (
minimum_time
) - 2๏ธโฃ
minimum_time
1๋ถ ์ ์์ ๊น์ง ์์ง ๋์ด๊ธฐ๊ตฌ ๋ชป ํ ์์ด๋ค์ด ๋ช ๋ช ์ธ์ง ์ฐพ๊ธฐ (remained_kid
) - 3๏ธโฃ
rids[]
๋ฅผ ๋๋ฉฐ, (rides[]
%minimum_time
== 0)์ธ ๋์ด๊ธฐ๊ตฌ๋ฅผ ๋ง๋ ๋๋ง๋คremained_kid
-- - 4๏ธโฃ
remained_kid
= 0 ์ธ ๋ ์์ ์ ride[] ๋ฒํธ๊ฐ ๊ณง ๋ต
(1) ํด์ค
1๏ธโฃ K๋ถ์ ์์ด๋ค์ด ๋์ ๋ช ๋ช ๋์ด๊ธฐ๊ตฌ์ ํ๋์ง ํ์ธํ๋ ๋ฐฉ๋ฒโจ
๋ค์์ ๋ฌธ์ ์์ 3๋ฒ ์์ด ์: 22, ๋์ด๊ธฐ๊ตฌ ์: 5, ๊ฐ๊ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ: [1,2,3,4,5]
์ ๋ํ ํ์ด๋ค. ์๊ฐ ๋จ์๋ฅผ ๋ถ์ผ๋ก ๋์์ ๋, ๊ฐ ์๊ฐ๋ง๋ค ๋์ด๊ธฐ๊ตฌ์ ํ์ผ๋ฉด .
์ผ๋ก ํ์ํ๋ค.
0๋ถ์งธ๋ ๋ชจ๋ ๋์ด๊ธฐ๊ตฌ์ ๋ค ํ๋ค. 0๋ถ์งธ ํ ๊ฒฝ์ฐ๋ฅผ ์ ์ธํ๊ณ ๋ณด๋ฉด, ๋์ด๊ธฐ๊ตฌ i์ K๋ถ ๋์ ์๋์ K/๋์ด๊ธฐ๊ตฌ ๊ฑธ๋ฆฌ๋ ์๊ฐ ์ด๋ค. ์๋ฅผ ๋ค์ด 1๋ฒ ๋์ด๊ธฐ๊ตฌ๋ 1๋ถ๋ง๋ค ํ ์ ์๋๋ฐ, 8๋ถ์งธ์ ์ด 8๋ช
์ด ๋์ ํด์ ํ ๊ฒ์ ํ์ธํ ์ ์๋ค. 4๋ฒ ๋์ด๊ธฐ๊ตฌ๋ 8๋ถ์งธ์ ์ด 2๋ถ์ด ํ๋ค.
์ฌ๊ธฐ์ ์ค์ํ ์ ์ 0๋ถ์งธ ํ ๊ฒฝ์ฐ๋ ์ ์ธํ๋ค๋ ๊ฒ์ด๋ค. ๋ง์ฝ ํด๋น ๊ฒฝ์ฐ๋ ๋์ ์ ํฌํจ์ํค๋ฉด ๋งค ๊ณ์ฐ๋ง๋ค + 1์ ํด์ค์ผ ํด์ ๋ฒ๊ฑฐ๋กญ๋ค. ๋ฐ๋ผ์ ํ์๋ 0๋ถ์งธ ํ ์ธ์ ์๋ ๋ฏธ๋ฆฌ ์ ํ๊ณ ๊ณ์ฐํ ์์ ์ด๋ค.
2๏ธโฃ ๋ชจ๋ ์ด๋ฆฐ์ด๊ฐ ๋ค ํ ์ ์๋ ์ต์ ์๊ฐ ์ฐพ๊ธฐ
์ฐ๋ฆฌ๋ ์ด์ K๋ถ์ ์๋์ด ๋์ ํด์ ์ผ๋ง๋ ํ๋์ง ํ ๋ฒ์ Loop๋ก ์ ์ ์๊ฒ ๋์๋ค. ์ด์ Parametric Search
์ ๊ทผ ๋ฐฉ๋ฒ์ ํ์ฉํด ์ต์ ํ ๋ฌธ์ ๋ฅผ ์ฌ๋ฌ ๊ฐ์ ๊ฒฐ์ ๋ฌธ์ ๋ก ๋ฐ๊ฟ ์๊ฐ์ด๋ค. ๋ค์๊ณผ ๊ฐ์ด ๋ฐ๊พธ๋ฉด ๋๋ค.
N๋ช
์ด ์ ๋ถ ํ๋ ์ต์ ์๊ฐ ๊ตฌํ๊ธฐ
โ mid ๋ถ์ ๋ชจ๋ ์์ด๋ค์ด ๋์ด๊ธฐ๊ตฌ์ ํ ์ ์๋๊ฐ? (f(d))
๊ฒฐ์ ๋ฌธ์ ์ธ f(d)
๋ ํด์ค 1๏ธโฃ์์ ๊ตฌํ์์ผ๋ก ์ด์ , ์ด๋ฅผ ์ด์ฉํด ์ด๋ถ ํ์์ ํ์ฌ f(d)
= true
์ธ ๊ฐ ์ค ์ ์ผ ์ผ์ชฝ์ ์๋ ๊ฐ์ ์ฐพ์ผ๋ฉด ๋๋ค.
3๏ธโฃ remained_kid
๊ตฌํ๋ ์ด์
ํด๋น ๋ฌธ์ ๊ฐ ๊ณจ๋ 1
์ธ ์ด์ ๋ ์ต์ ์๊ฐ ์์ฒด๋ฅผ ๊ตฌํ๋ ๊ฒ์ด ์๋๋ผ, ๋ง์ง๋ง์ผ๋ก ํ๋ ๋์ด๊ธฐ๊ตฌ์ ๋ฒํธ๋ฅผ ๊ตฌํ๋๋ก ํ ๋ฒ ๋ ๊ผฌ์๊ธฐ ๋๋ฌธ์ด๋ค. remained_kid
๋ ์ด๋ฅผ ์ํด ํ์ํ๋ค. ๋ง์ง๋ง ๋์ด๊ธฐ๊ตฌ ๋ฒํธ๋ฅผ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ๋ค.
- โถ ๋ชจ๋ ์์ด๋ค์ด ์ ๋ถ ํ๋ ์ต์ ์๊ฐ์
k
๋ผ๊ณ ํ์ ๋,k-1
๋ถ์ ๋ชป ํ๋ ์์ด๋ค ๊ตฌํ๊ธฐ (์ด ์ ๋ค์K
๋ถ์ ํ๋ ์ ๋ค์) - โท ์ด์
remained_kid
๋ฅผ ํ ๋ช ์ฉ ํ์ฐ๋ฉฐ ๋ง์ง๋ง ๋์ด๊ธฐ๊ตฌ ๋ฒํธ๋ฅผ ๊ตฌํ๋ค.
4๏ธโฃ K๋ถ์ ํด๋น ๋์ด๊ธฐ๊ตฌ๊ฐ ๋น์๋์ง ์ด์ผ ์?
์๊น ์ฐ๋ฆฌ๊ฐ ๋งค ๋ถ๋ง๋ค ์์ด๋ค์ ๋์ด๊ธฐ๊ตฌ์ ํ์ ์ ๋๋ฅผ ๊ธฐ์ตํ๋๊ฐ? 2๋ถ๋ง๋ค ๋น๋ ๋์ด๊ธฐ๊ตฌ๋ 2,4,6๋ถ์ ํ์ ๊ณ , 3๋ถ ๋ง๋ค ๋น๋ ๋์ด๊ธฐ๊ตฌ๋ 3,6์ ํ์ ๋ค. ์ด ๋์ด๊ธฐ๊ตฌ๋ ๋ถ๋ช 9๋ถ์๋ ๋น์ด์์ ๊ฒ์ด๋ค. ์ฆ ํ์ฌ๋ฅผ k๋ถ์ด๋ผ ํ๋ฉดk/๋์ด๊ธฐ๊ตฌ์ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ๋๋จธ์ง๊ฐ 0์ธ ์๊ฐ์ด ๋ฐ๋ก ๋์ด๊ธฐ๊ตฌ๊ฐ ๋น์ด ์๋ ์๊ฐ์ด๋ค.
์์ ์์์์๋ 8๋ถ์งธ์ ๋น์ด ์๋ ๋์ด๊ธฐ๊ตฌ๋ 1
,2
,4
๋ฒ ๋์ด๊ธฐ๊ตฌ ์๋ค.
(2) ์๊ฐ๋ณต์ก๋ ๋ถ์ ๐
N
: ๋์ด๊ธฐ๊ตฌ ํ๋ ์์ด ์, M
: ๋์ด๊ธฐ๊ตฌ ์
- ๋์ด๊ธฐ๊ตฌ ์๊ฐ ์ ๋ ฅ: $O(M)$
- ๋ชจ๋ ํ์ฐ๋ ์ต์ ์๊ฐ ๊ตฌํ๊ธฐ: $O( 30N \log 30N)$ (30 = ๋์ด๊ธฐ๊ตฌ ์ด์ฉ์ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ์ต๋๊ฐ)
- ์ต์ ์๊ฐ ๋๋ ์ง ํ์ธ: $O(M)$
remained_kid
๊ตฌํ๊ธฐ : $O(M)$- ๋ต ๊ตฌํ๊ธฐ: $O(M)$
์ด ์๊ฐ ๋ณต์ก๋
: $O(M + 30N \log 30N)$
3. ์ฝ๋ ์๊ฐ ๐
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Main {
static int N, M;
static long minimum_time, remained_kid;
static int [] rides;
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());
M = Integer.parseInt(st.nextToken());
rides = new int [M];
st = new StringTokenizer(br.readLine());
for (int i = 0; i < M; i++) {
rides[i] = Integer.parseInt(st.nextToken());
}
if(M >= N) { // ๋์ด๊ธฐ๊ตฌ๋ณด๋ค ์ฌ๋์๊ฐ ์ ๊ฑฐ๋ ๊ฐ์ ๊ฒฝ์ฐ, ์ฌ๋์ ์๋ฒ์ด ๊ณง ํ๋ ๋์ด๊ธฐ๊ตฌ
System.out.println(N);
return;
}
N -= M;
minimum_time = binary_search();
remained_kid = N - before_minimum_time_kiddo_cnt(minimum_time);
System.out.println(last_rides_num(remained_kid));
}
// N๋ช
์ ์์ด๋ฅผ ๋ชจ๋ ํ์ธ ์ ์๋ ์ต์ ์๊ฐ ์ฐพ๋ ํจ์
public static long binary_search() {
long start = 0;
long end = 30 * (long)Integer.MAX_VALUE;
while (start <= end) {
long mid = (start + (end - start)/2);
if(f(mid)) end = mid -1;
else start = mid + 1;
}
return start;
}
// N๋ช
์ ์
๋ ฅ ๋ฐ์ ์๊ฐ ๋ด๋ก ๋ชจ๋ ํ์ธ ์ ์์ผ๋ฉด true, ์๋๋ฉด false ๋ฐํํ๋ ํจ์
public static boolean f(long time) {
long kids = 0;
for (int i = 0; i < M; i++) {
kids += time/rides[i];
}
return N <= kids;
}
// ์ต์์๊ฐ - 1๋ถ ์์ ์ ๋จ์์๋ ์์ด ์ ๊ตฌํ๋ ํจ์
public static long before_minimum_time_kiddo_cnt( long minimum_time){
long kids = 0;
for (int i = 0; i < M; i++) {
kids += (minimum_time-1)/rides[i];
}
return kids;
}
// ๋ง์ง๋ง ๋์ด๊ธฐ๊ตฌ ๋ฒํธ ๊ตฌํ๋ ํจ์
public static int last_rides_num(long kids_cnt) {
for (int i = 0; i < M; i++) {
if(minimum_time%rides[i] == 0) kids_cnt--;
if(kids_cnt == 0) return i+1;
}
return -1;
}
}
4. ๋ฐฐ์ด ๊ฒ๋ค ๐ฏ
๋ฌธ์ ๋ฅผ ์ด๋ ๊ฒ๋ ๋ผ ์ ์๊ตฌ๋ ๋ฐฐ์ ๋ค.