๋ฌธ์
์๊ฐ ์ ํ : 0.15์ด
๋ฉ๋ชจ๋ฆฌ ์ ํ : 128MB
๋ ์์ ๋ฌํฝ์ด๊ฐ ์๋ค. ์ด ๋ฌํฝ์ด๋ ๋์ด๊ฐ V๋ฏธํฐ์ธ ๋๋ฌด ๋ง๋๋ฅผ ์ฌ๋ผ๊ฐ ๊ฒ์ด๋ค.
๋ฌํฝ์ด๋ ๋ฎ์ A๋ฏธํฐ ์ฌ๋ผ๊ฐ ์ ์๋ค. ํ์ง๋ง, ๋ฐค์ ์ ์ ์๋ ๋์ B๋ฏธํฐ ๋ฏธ๋๋ฌ์ง๋ค. ๋, ์ ์์ ์ฌ๋ผ๊ฐ ํ์๋ ๋ฏธ๋๋ฌ์ง์ง ์๋๋ค.
๋ฌํฝ์ด๊ฐ ๋๋ฌด ๋ง๋๋ฅผ ๋ชจ๋ ์ฌ๋ผ๊ฐ๋ ค๋ฉด, ๋ฉฐ์น ์ด ๊ฑธ๋ฆฌ๋์ง ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์ธ ์ ์ A, B, V๊ฐ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋์ด์ ์ฃผ์ด์ง๋ค. (1 ≤ B < A ≤ V ≤ 1,000,000,000)
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ๋ฌํฝ์ด๊ฐ ๋๋ฌด ๋ง๋๋ฅผ ๋ชจ๋ ์ฌ๋ผ๊ฐ๋๋ฐ ๋ฉฐ์น ์ด ๊ฑธ๋ฆฌ๋์ง ์ถ๋ ฅํ๋ค.
ํ์ด
๋ฌธ์ ์์ฒด๋ ๊ต์ฅํ ์ฝ๋ค. ํ๋ก๊ทธ๋๋ฐ ์ธ์ด ์ฑ ์ ์ ํ๊ฒ ๋๋ฉด ๋ ์ด๋ฐ๋ถ์ ๋ฑ์ฅํ๋ ๋ฌธ์ ์ค ํ๋์ธ๋ฐ
๋์ , ํด๋น ๋ฌธ์ ๋ ์๊ฐ ์ด๊ฐ ๊ฑธ๋ ค์์ด ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํด์๋ ์๋๋ค. ๋ฐ๋ผ์ ๊ฐ๋จํ ์ํ์ ์ฌ๊ณ ๋ ฅ์ด ์๊ตฌ๋์ด ์ง๋ค.
์ด ๋ฌธ์ ๋ฅผ ์ฝ๊ฒ ํ๊ธฐ ์ํด์๋ ์์ ์ด ์ง์ ๊ทธ๋ฆผ์ ๊ทธ๋ ค๋ณธ ํ, ์์์ ์์ฑํ๊ณ ์ฝ๋๋ฅผ ์์ฑํ๋ ๊ฒ์ด ์ข๋ค.
๋ฌํฝ์ด๋ A-B๋งํผ ๋ช๋ ์ ์ฌ๋ผ๊ฐ๊ณ , A๋งํผ ์ฌ๋ผ๊ฐ ํ ๋๋ฌํ๋ค๊ณ ๊ฐ์ ํ์. ๊ทธ๋ฌ๋ฉด ์๋ซ๋ถ๋ถ์ ๊ธธ์ด๋ V-A๊ฐ ๋ ๊ฒ์ด๊ณ
์ ๋ถ๋ถ์ A๊ฐ ๋ ๊ฒ์ด๋ค.
์ฌ๊ธฐ์ ์ง์ค์์ ๋ด์ผํ ๋ถ๋ถ์ ๋ฌํฝ์ด๊ฐ ๋ชฉํ์ ๋๋ฌํ ๋ ์ฆ, A ๋ถ๋ถ์ด๋ค.
1. ๋ง์ฝ, ์๋ซ ๋ถ๋ถ ์ฆ, V-A ์ A-B๋ฅผ ๋๋ด์ ๋ ๋๋จธ์ง๊ฐ ์๋ ๊ฒฝ์ฐ
2. ๋ฐ๋๋ก ๋๋จธ์ง๊ฐ ์๋ ๊ฒฝ์ฐ (์ฌ๊ธฐ์ ๋๋จธ์ง๋ ๋ฌด์กฐ๊ฑด A-B๋ณด๋ค ์๋ค.)
์ฒซ๋ฒ์งธ์ ๊ฒฝ์ฐ์๋ V-A / (A-B) + 1์ด ์ ๋ต์ด๋ค. ์๋ํ๋ฉด ๋๋จธ์ง๊ฐ ์๋ค๋ ๊ฒ์ ๋ฑ A๋งํผ ๋จ์๋ค๋ ์๋ฏธ์ด๊ธฐ ๋๋ฌธ์ ํ๋ฃจ๋ง ๋ ์ฌ๋ผ๊ฐ๋ฉด ๋ฌํฝ์ด๋ ๋ฏธ๋๋ฌ์ง ํ์ ์์ด ๋ชฉํ์ ๋๋ฌํ๊ฒ ๋๋ค.
ํ์ง๋ง ๋๋ฒ์งธ์ ๊ฒฝ์ฐ A + ๋๋จธ์ง ๋งํผ ๋ ์ฌ๋ผ๊ฐ์ผ ํ๊ธฐ ๋๋ฌธ์ ๋ฌํฝ์ด๋ A๋ฅผ ์ฌ๋ผ๊ฐ ํ ํ๋ฒ ๋ฏธ๋๋ฌ์ง ์ ๋ฐ์ ์๋ค.
๋ฐ๋ผ์ ์ฒซ๋ฒ์งธ์ ๋ค๋ฅด๊ฒ ํ๋ฃจ๋ฅผ ๋ ์ถ๊ฐ์ ์ผ๋ก ์ฌ๋ผ๊ฐ์ผ ํ๊ธฐ ๋๋ฌธ์ +2๋ฅผ ํด์ค์ผ ํ๋ค. ์ฌ๊ธฐ์ ๋๊ตฐ๊ฐ๋ ์๋ฌธ์ ๊ฐ์ง ์๋ ์๋ค. "1์ผ์ด ์๋๋ผ ๊ทธ ์ด์์ ๋ ์ฌ๋ผ๊ฐ์๋ ์์ง ์์๊น?"๋ผ๊ณ ๋ง์ด๋ค. ํ์ง๋ง ์์ ์ธ๊ธํ ๊ฒ์ฒ๋ผ ๋๋จธ์ง ๊ฐ์ A-B (A > A-B, B >= 0) ๋ณด๋ค ๋ฌด์กฐ๊ฑด ์์ ์ ๋ฐ์ ์๊ธฐ ๋๋ฌธ์ 1์ผ์ ์ด๊ณผํ ์๊ฐ ์๋ค.
์ฝ๋
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
class Snail {
int A;
int B;
Snail(int A, int B) {
this.A = A;
this.B = B;
}
}
public class snailCheck {
public static void main(String[] args) {
int V,A,B = 0;
Scanner scanner = new Scanner(System.in);
A = scanner.nextInt();
B = scanner.nextInt();
V = scanner.nextInt();
Snail snail = new Snail(A,B);
System.out.println(snailDayCheck(V,snail.A,snail.B));
}
public static int snailDayCheck(int V,int A,int B) {
int sum = 0;
int day = 0;
int other = 0;
int V2 = 0;
V2 = V - A;
day = V2 / (A-B);
other = V2 % (A-B);
if(other == 0)
return day + 1;
return day + 2;
}
}
|