๋ฌธ์
์๋์ ์๋ ๋ ธํธ๋ถ์ ์ ์กฐํ๊ณ ํ๋งคํ๋ ํ์ฌ์ด๋ค. ๋ ธํธ๋ถ ํ๋งค ๋์์ ์๊ด์์ด ๋งค๋ ์๋๋ฃ, ์ฌ์ฐ์ธ, ๋ณดํ๋ฃ, ๊ธ์ฌ ๋ฑ A๋ง์์ ๊ณ ์ ๋น์ฉ์ด ๋ค๋ฉฐ, ํ ๋์ ๋ ธํธ๋ถ์ ์์ฐํ๋ ๋ฐ์๋ ์ฌ๋ฃ๋น์ ์ธ๊ฑด๋น ๋ฑ ์ด B๋ง์์ ๊ฐ๋ณ ๋น์ฉ์ด ๋ ๋ค๊ณ ํ๋ค.
์๋ฅผ ๋ค์ด A=1,000, B=70์ด๋ผ๊ณ ํ์. ์ด ๊ฒฝ์ฐ ๋ ธํธ๋ถ์ ํ ๋ ์์ฐํ๋ ๋ฐ๋ ์ด 1,070๋ง์์ด ๋ค๋ฉฐ, ์ด ๋ ์์ฐํ๋ ๋ฐ๋ ์ด 1,700๋ง์์ด ๋ ๋ค.
๋ ธํธ๋ถ ๊ฐ๊ฒฉ์ด C๋ง์์ผ๋ก ์ฑ ์ ๋์๋ค๊ณ ํ๋ค. ์ผ๋ฐ์ ์ผ๋ก ์์ฐ ๋์๋ฅผ ๋๋ ค ๊ฐ๋ค ๋ณด๋ฉด ์ด๋ ์๊ฐ ์ด ์์ (ํ๋งค๋น์ฉ)์ด ์ด ๋น์ฉ(=๊ณ ์ ๋น์ฉ+๊ฐ๋ณ๋น์ฉ)๋ณด๋ค ๋ง์์ง๊ฒ ๋๋ค. ์ต์ด๋ก ์ด ์์ ์ด ์ด ๋น์ฉ๋ณด๋ค ๋ง์์ ธ ์ด์ต์ด ๋ฐ์ํ๋ ์ง์ ์ ์์ต๋ถ๊ธฐ์ (BREAK-EVEN POINT)์ด๋ผ๊ณ ํ๋ค.
A, B, C๊ฐ ์ฃผ์ด์ก์ ๋, ์์ต๋ถ๊ธฐ์ ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ A, B, C๊ฐ ๋น ์นธ์ ์ฌ์ด์ ๋๊ณ ์์๋๋ก ์ฃผ์ด์ง๋ค. A, B, C๋ 21์ต ์ดํ์ ์์ฐ์์ด๋ค.
์ถ๋ ฅ
์ฒซ ๋ฒ์งธ ์ค์ ์์ต๋ถ๊ธฐ์ ์ฆ ์ต์ด๋ก ์ด์ต์ด ๋ฐ์ํ๋ ํ๋งค๋์ ์ถ๋ ฅํ๋ค. ์์ต๋ถ๊ธฐ์ ์ด ์กด์ฌํ์ง ์์ผ๋ฉด -1์ ์ถ๋ ฅํ๋ค.
์์ ์ ๋ ฅ 1
1000 70 170
์์ ์ถ๋ ฅ 1
11
์์ ์ ๋ ฅ 2
3 2 1
์์ ์ถ๋ ฅ 2
-1
ํ์ด
1. ๋ ธํธ๋ถ์ด n๋ ํ๋งค๋์๋ค๊ณ ํ ๋ ์์ต๋ถ๊ธฐ์ ์ ๊ตฌํ๋ ์์ n > A / ( C - B )
2. ํด๋น ์๋ณด๋ค ํฐ ์์ฐ์๋ฅผ ๊ตฌํ์ฌ์ผ ํ๊ธฐ ๋๋ฌธ์ intํ d ์ (double)a / ( (double)c - (double)b ) + 1์ ์ ์ฅ
(doubleํ์ int๋ก ์ ์ฅํ๋ฉด ๋๋จธ์ง๋ฅผ ๋ค ๋ฒ๋ฆฌ๊ณ ์ ์ ๋ถ๋ถ๋ง ๋จ๊ธฐ ๋๋ฌธ์)
3. d๊ฐ 1๋ณด๋ค ์๋ค๋ฉด ์์ต๋ถ๊ธฐ์ ์ด ์กด์ฌํ์ง ์๊ธฐ ๋๋ฌธ์ -1์ ์ถ๋ ฅ, ์๋๋ฉด d๋ฅผ ์ถ๋ ฅ
import java.io.IOException;
import java.util.Scanner;
import java.util.StringTokenizer;
public class B1712 {
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
StringTokenizer st = new StringTokenizer(sc.nextLine());
String a = st.nextToken();
String b = st.nextToken();
String c = st.nextToken();
int d = (int) (Double.parseDouble(a) / ( Double.parseDouble(c) - Double.parseDouble(b) )) + 1;
if(d < 1) {
System.out.println("-1");
} else {
System.out.println(d);
}
}
}