๋ฐฑ์ค 14298๋ฒ, Vote (with.Java)
๋ฐฑ์ค 14298๋ฒ, Vote (with.Java) ์ ๋ํ์ฌ ์์๋ณธ ๊ธ์ ๋๋ค.
์ฝ๋ฉ ํ ์คํธ ๋ฌธ์ ๋ฅผ ํ๋ฉฐ, ํ์๋ ๋ฌธ์ ์ ๋ํ ํ๊ณ ์ ๋ค๋ฅธ ํ์ด ๋ฐฉ๋ฒ์ ์์๋ณด๋ฉฐ, ์์๊ฐ๊ณ ์ ํฉ๋๋ค.
๋ฌธ์ ์ ๋ํด ๋จผ์ ์์๋ณด๊ฒ ์ต๋๋ค.
๋ฌธ์
A์ B๋ ํน์ ์ ๊ฑฐ์์ ๊ฒฝ์ํ๋ ์ ์ผํ ๋ ํ๋ณด์ ๋๋ค.
์ฐ๋ฆฌ๋ ์ฌ๋ก ์กฐ์ฌ๋ฅผ ํตํด ์ ํํ N๋ช ์ ์ ๊ถ์๊ฐ A๋ฅผ ์ง์งํ๊ณ ์ ํํ M๋ช ์ ์ ๊ถ์๊ฐ B๋ฅผ ์ง์งํ๋ค๋ ๊ฒ์ ์๊ณ ์์ต๋๋ค.
๋ํ N์ด M๋ณด๋ค ํฌ๋ฏ๋ก A๊ฐ ์ด๊ธธ ๊ฒ์ด๋ผ๋ ๊ฒ๋ ์๊ณ ์์ต๋๋ค.
์ ๊ถ์๋ค์ ํ ๋ฒ์ ํ ๋ช ์ฉ ํฌํ์์ ๋ํ๋๋ฉฐ, ๋ชจ๋ ๊ฐ๋ฅํ (N + M)! ์์์์ ๊ท ์ผํ๊ฒ ๋ฌด์์๋ก ์ ํ๋ ์์๋ก ๋ํ๋ฉ๋๋ค.
๊ฐ ์ ๊ถ์๊ฐ ํฌํ๋ฅผ ํ ํ, ํฌํ์ ์ง์์ ๊ฒฐ๊ณผ๋ฅผ ์ ๋ฐ์ดํธํ๊ณ ์ง๊ธ๊น์ง ์ด๋ ํ๋ณด๊ฐ ์น๋ฆฌํ๋์ง(์๋ ๊ฒฝ์ฐ) ๊ธฐ๋กํฉ๋๋ค.
(ํฌํ๊ฐ ๋์ ์ธ ๊ฒฝ์ฐ, ์ด๋ ํ๋ณด๋ ์น๋ฆฌํ ๊ฒ์ผ๋ก ๊ฐ์ฃผ๋์ง ์์ต๋๋ค.)
A๊ฐ ํญ์ ์ ๋๋ฅผ ์ ์งํ ํ๋ฅ ์ ์ผ๋ง์ธ๊ฐ?
์ฆ, A๊ฐ ๋ชจ๋ ํฌํ์์ ํญ์ ์ด๊ธธ ํ๋ฅ ์ ์ผ๋ง์ธ๊ฐ?
์ ๋ ฅ
์ ๋ ฅ์ ํ ์คํธ ์ผ์ด์ค์ ์์ธ ์ ์ T๋ฅผ ํฌํจํ๋ ํ ์ค๋ก ์์ํฉ๋๋ค.
๊ฐ ํ ์คํธ ์ผ์ด์ค๋ ๊ฐ๊ฐ A์ B๋ฅผ ์ง์งํ๋ ์ ๊ถ์์ ์์ธ ๋ ์ ์ N๊ณผ M์ ํฌํจํ๋ ํ ์ค๋ก ๊ตฌ์ฑ๋ฉ๋๋ค.
์ ํ
1 โค T โค 100.
0 โค M < N โค 10.
์ถ๋ ฅ
๊ฐ ํ ์คํธ ์ผ์ด์ค์ ๋ํด ๋ค์์ด ํฌํจ๋ ํ ์ค์ ์ถ๋ ฅํฉ๋๋ค.
Case #x: y. ์ฌ๊ธฐ์ ๋ x ํ ์คํธ ์ผ์ด์ค ๋ฒํธ(1๋ถํฐ ์์)์ด๊ณ , ๋ y ๋ชจ๋ ํฌํ์์ A๊ฐ ํญ์ ์ด๊ธธ ํ๋ฅ ์ ๋๋ค.
y ์ ๋ต์ y ์ ๋์ค์ฐจ ๋๋ ์๋์ค์ฐจ๊ฐ 10-6 ์ด๋ด์ด๋ฉด ์ ๋ต ์ผ๋ก ๊ฐ์ฃผํฉ๋๋ค.
๋ฌธ์ ํ์ด
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int T = Integer.parseInt(br.readLine());
StringBuilder sb = new StringBuilder();
for(int i = 1; i <= T; i++) {
StringTokenizer st = new StringTokenizer(br.readLine());
int N = Integer.parseInt(st.nextToken());
int M = Integer.parseInt(st.nextToken());
double p = (double) (N - M) / (N + M);
sb.append(String.format("Case #%d: %.8f\n", i, p));
}
System.out.print(sb);
}
}
ํ์ด ์ค๋ช
์ด ์ฝ๋๋ ํน์ ์ ๊ฑฐ์์ A ํ๋ณด๊ฐ ํญ์ ์ ๋๋ฅผ ์ ์งํ ํ๋ฅ ์ ๊ณ์ฐํ๋ ํ๋ก๊ทธ๋จ์ ๋๋ค.
๋จผ์ BufferedReader๋ฅผ ์ฌ์ฉํ์ฌ ์ ๋ ฅ์ ๋น ๋ฅด๊ฒ ์ฝ์ด์ค๊ณ ์ฒซ ๋ฒ์งธ ์ ๋ ฅ๊ฐ์ ์ฝ์ด ์ ์ T์ ์ ์ฅํ๋๋ฐ, ์ด๋ ํ ์คํธ ์ผ์ด์ค์ ๊ฐ์๋ฅผ ์๋ฏธํฉ๋๋ค.
์ดํ for๋ฌธ์ ์ด์ฉํ์ฌ i = 1๋ถํฐ T๊น์ง ๋ฐ๋ณตํ๋ฉด์ ๊ฐ ํ ์คํธ ์ผ์ด์ค๋ฅผ ์ฒ๋ฆฌํฉ๋๋ค.
StringTokenizer๋ฅผ ์ฌ์ฉํ์ฌ ํ ์ค์ ๊ณต๋ฐฑ ๊ธฐ์ค์ผ๋ก ๋๋๊ณ ๊ฐ๊ฐ N(A๋ฅผ ์ง์งํ๋ ์ ๊ถ์ ์)๊ณผ M(B๋ฅผ ์ง์งํ๋ ์ ๊ถ์ ์)๋ก ๋ณํํฉ๋๋ค.
A๊ฐ ํญ์ ์ ๋๋ฅผ ์ ์งํ ํ๋ฅ p๋ Ballot Theorem ๊ณต์์ ํ์ฉํ์ฌ (N - M) / (N + M)์ผ๋ก ๊ณ์ฐํฉ๋๋ค.
์ฌ๊ธฐ์ N - M์ A๊ฐ B๋ณด๋ค ์์์ผ ํ๋ ์ฐจ์ด๋ฅผ ๋ํ๋ด๊ณ N + M์ ์ ์ฒด ์ ๊ถ์ ์๋ฅผ ์๋ฏธํ๋ฏ๋ก ์ด ํ๋ฅ ์ A๊ฐ ํญ์ ์ ๋๋ฅผ ์ ์งํ ํ๋ฅ ์ ์๋ฏธํฉ๋๋ค.
์ดํ String.format(โCase #%d: %.8f\nโ, i, p)๋ฅผ ์ฌ์ฉํ์ฌ ๋ฌธ์ ์์ ์๊ตฌํ๋ ์ถ๋ ฅ ํ์์ ๋ง์ถ๋ค.
โCase #%dโ๋ ํ ์คํธ ์ผ์ด์ค ๋ฒํธ๋ฅผ ๋ํ๋ด๊ณ โ%.8fโ๋ ์์์ 8์๋ฆฌ๊น์ง ํ๋ฅ ๊ฐ์ ์ถ๋ ฅํ๋ฉฐ \n์ ์ถ๊ฐํ์ฌ ์ค๋ฐ๊ฟ์ ํ๋ค.
๊ทธ๋ฆฌ๊ณ StringBuilder๋ฅผ ํ์ฉํ์ฌ ๋ฌธ์์ด์ ๋์ ํ ํ System.out.print(sb)๋ฅผ ์ฌ์ฉํ์ฌ ํ ๋ฒ์ ์ถ๋ ฅํ๋๋ฐ ์ด๋ ๊ฒ ํ๋ฉด ์ฌ๋ฌ ๋ฒ System.out.println()์ ํธ์ถํ๋ ๊ฒ๋ณด๋ค ์ฑ๋ฅ์ด ํฅ์๋ฉ๋๋ค.
์์ ์ ๋ ฅ 2 2 1 1 0์ด ์ฃผ์ด์ก์ ๋ ์ฒซ ๋ฒ์งธ ํ ์คํธ ์ผ์ด์ค(2, 1)์ ํ๋ฅ ์ (2-1) / (2+1) = 1/3 = 0.33333333์ด ๋๊ณ ๋ ๋ฒ์งธ ํ ์คํธ ์ผ์ด์ค(1, 0)์ ํ๋ฅ ์ (1-0) / (1+0) = 1/1 = 1.00000000์ด ๋ฉ๋๋ค.
๊ฐ ํ ์คํธ ์ผ์ด์ค์์ N๊ณผ M์ ์ ๋ ฅ๋ฐ๊ณ ๋จ์ ์ฐ์ฐ์ ์ํํ๋ฏ๋ก O(1)์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋ฉฐ ์ ์ฒด์ ์ผ๋ก O(T)์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋๋ค.
T๊ฐ ์ต๋ 100์ด๊ณ N๊ณผ M์ ์ต๋๊ฐ์ด 10์ด๋ฏ๋ก ๋งค์ฐ ๋น ๋ฅด๊ฒ ์คํ๋๋ค.