Tags
- ์ ์๋ก
- BFS
- greedy
- ๊น์ด ์ฐ์ ํ์
- DP
- Dynamic Programming
- LV2
- ์ํ
- Study
- queue
- ์ ๋ ฌ
- sort
- Brute Force Algorithm
- ์๋ฎฌ๋ ์ด์
- ๊ทธ๋ํ ํ์
- ๊ตฌํ
- CodingTest
- BOJ
- PGM
- ๊ทธ๋ํ ์ด๋ก
- ๋๋น ์ฐ์ ํ์
- Java
- ๊ต์ฌ
- ๋ฐฑํธ๋ํน
- Python
- ๋ฌธ์์ด
- SpringBoot
- stack
- dfs
- ์๋ฃ๊ตฌ์กฐ
Archives
๊ธฐ๋ก๋ฐฉ
BOJ_13172 : Σ ๋ณธ๋ฌธ
๐ธ ๋ฌธ์ ๋ถ์ ๐ธ
- ์ฃผ์ฌ์ M๊ฐ์ ๋ํด i๋ฒ์งธ ์ฃผ์ฌ์์ ๋ฉด ๊ฐ์๋ Ni, ๋ฉด์ ๋ชจ๋ ๊ฐ์ ์ดํฉ์ Si๋ก ์ ๋ ฅ๋๋ค.
- ๋ชจ๋ ์ฃผ์ฌ์๋ฅผ ๋์ก์ ๋์ ๊ธฐ๋๊ฐ์ ๊ณ์ฐํ๋ค.
- S1/N1 + S2/N2 + ... + SM/NM ๊ณ์ฐ์ ์ด๋ ค์ ๋๋ฌธ์ ์์์ ๋ถ์ a / b๋ฅผ ๋ชจ๋๋ฌ๋ฅผ ์ด์ฉํด (a * b-1 mod x)์ ์ ์ ๊ฐ์ผ๋ก ๊ณ์ฐํ๋ค.
๐ธ ๋ฌธ์ ํ์ด ๐ธ
- ๋ฌธ์ ์ ์ํ ์ด๋ก ์ค๋ช ์ด ๊ฝค ๊ธธ์ง๋ง, ์ฝ์ด๋ณด๋ฉด ์ดํด ๋ชปํ ์ ๋๋ ์๋๋ค. ๋ณด๋ค ์ ํํ ํ๋ฅ ๊ณ์ฐ์ ์ํด ๋ชจ๋๋ฌ ํํ ๋ฐฉ์์ ์ฌ์ฉํ๋ค๋ ๊ฒ์ด๋ค.
- ๋ฌธ์ ์์ ์ ์๋ ๊ณต์์ ์ฌ์ฉํ๋ฉด ๋๋๋ฐ, ์ค์ํ๊ฑด a/b๋ฅผ a * b^-1 mod X๋ก ๋ณํํด ๋์ ํ๋ ๊ฒ์ด๋ค.
- b^-1 (mod X)์ ํ๋ฅด๋ง์ ์์ ๋ฆฌ์ ์ํด b^(X-2) (mod X)์ ๊ฐ๋ค๊ณ ํ๋ค.
- ๋ชจ๋๋ฌ ๊ฐ์ด 1,000,000,007์ด๋ฏ๋ก, S * N^(1,000,000,007 - 2) % 1,000,000,007 ๊ฐ์ ๋์ ํ ์ถ๋ ฅํ๋ค.
- ๊ฑฐ๋ญ์ ๊ณฑ์ ๊ฐ์ด ๋ชจ๋๋ฌ ๊ฐ-2 ๋ก ์์ฃผ ํฌ๋ฏ๋ก ๋น ๋ฅธ ๊ฑฐ๋ญ์ ๊ณฑ ์๊ณ ๋ฆฌ์ฆ (Fast Power Algorithm)์ ์ฌ์ฉํ๋ค.
๐ธ ์ฝ๋ ๐ธ
import java.io.*;
import java.util.StringTokenizer;
public class Main {
private static final int MOD = 1_000_000_007;
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
int M = Integer.parseInt(br.readLine());
long answer = 0;
for (int i = 0; i < M; i++) {
StringTokenizer st = new StringTokenizer(br.readLine());
int N = Integer.parseInt(st.nextToken()); // ์ฃผ์ฌ์ ๋ฉด ๊ฐ์
int S = Integer.parseInt(st.nextToken()); // ์ฃผ์ฌ์ ๋ฉด ์ดํฉ
long b = S * fast_power_algorithme(N, MOD - 2) % MOD;
answer = (answer + b) % MOD;
}
bw.write(Long.toString(answer));
bw.flush();
}
private static long fast_power_algorithme(long a, int n) {
long r = 1;
while (n > 0) {
if ((n & 1) == 1) r = r * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return r;
}
}
๐ธ ์ฝ๋ ํด์ ๐ธ
- ์ฃผ์ฌ์ ๋ฉด์ ๊ฐ์ N๊ณผ ์ฃผ์ฌ์ ๊ฐ์ ์ดํฉ S๋ฅผ ์
๋ ฅ๋ฐ์ ๊ธฐ๋๊ฐ์ ๊ณ์ฐํด ๋์ ํ๋ค.
- ๊ธฐ๋๊ฐ์ S/N์ผ๋ก ๊ณ์ฐํ๋๋ฐ, ๋ฌธ์ ์์ ์ ์๋ ๋ชจ๋๋ฌ ๊ณต์์ ๋ฐ๋ผ S * (N์ mod-1 ์ ๊ณฑ) %mod๋ก ๊ณ์ฐํ๋ค.
- ๊ฑฐ๋ญ์ ๊ณฑ์ ์๊ฐ ํฌ๋ฏ๋ก ๋น ๋ฅธ ๊ฑฐ๋ญ์ ๊ณฑ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๊ธฐ ์ํด fast_power_algorithm() ๋ฉ์๋๋ฅผ ๊ตฌํํ๋ค.
- ๋นํธ ๋จ์๋ก ํ์ธํด ๊ฐ์ ๊ฑฐ๋ญ์ ๊ณฑํ๋ค. ์ด๋ ๊ฐ์ mod๋ก ๋ชจ๋๋ฌ ์ฐ์ฐ์ ํด์ ๊ฐ์ด ์ปค์ง์ง ์๋๋ก ํ๋ค.
- ๊ฐ์ ๋์ ํ ๋๋ ๋ชจ๋๋ฌ ์ฐ์ฐ์ ๋ฐ๋ณตํ๋ค.
- ๋์ ๊ฐ์ ์ถ๋ ฅํ๋ค.
๐ธ end ๐ธ
- ์ด๋ฐ์ ๋ฌธ์ ์ดํด๋ ์ด๋์ ๋ ํ์ง๋ง, ์ฃผ์ด์ง ๊ณต์์ ์ฝ๋๋ก ์ด๋ป๊ฒ ์ฎ๊ฒจ์ผ ํ๋ค๋ ๊ฑด์ง ๊ฐ์ ์ก์ง ๋ชปํด ํ์ด๋ฅผ ์ฐธ๊ณ ํ๋ค.
- ํด๋น ๋ฌธ์ ์ C++ํ์ด ์ง๋ฌธ๊ธ์ ์ฐธ๊ณ ํ๋๋ฐ, ๋ฐ๋ก ์ดํด๊ฐ ๋์ด์ ํ์ดํ ์ ์์๋ค.
- ์ง๋ฌธ๊ธ์ ๊ฑฐ๋ญ์ ๊ณฑ์ ํน์ดํ๊ฒ ๊ตฌํํ๊ธธ๋ ์ฐพ์๋ณด์๋๋ฐ ๋น ๋ฅธ ๊ฑฐ๋ญ์ ๊ณฑ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๋ค๋ ๊ฑธ ์ ์ ์์๋ค.
- Math.pow๋ก ๊ณ์ฐํ์๋๋ ์ฃผ์ด์ง ๋ชจ๋๊ฐ์ ๊ณ์ฐํ์ง ๋ชปํ๊ณ Infinity๊ฐ ๋ฌ์๋ค.
- ๋น ๋ฅธ ๊ฑฐ๋ญ์ ๊ณฑ ์๊ณ ๋ฆฌ์ฆ ์ค๋ช ํฌ์คํ ์ ์ฐธ๊ณ ํด ์๋ฆฌ๋ฅผ ์ดํดํ๊ณ ์ ์ฉํ๋ค.
- ๊ตฌํํ๊ณ ๋ณด๋ ์ง๋ฌธ๊ธ์ ๊ตฌํ๋์ด ์๋ ํํ๊ฐ ๊ทธ๋๋ก ์ ์ฉ๋์ด์ ์กฐ๊ธ ํ๋ฌดํ์ง๋ง ์ข์ ๊ณต๋ถ๊ฐ ๋์๋ค.
- ํ๊ณ ๋์ ์๊ณ ๋ฆฌ์ฆ ๋ถ๋ฅ๋ฅผ ๋ณด๋, ๋ถํ ์ ๋ณต์ ์ด์ฉํ ๊ฑฐ๋ญ์ ๊ณฑ, ๋ชจ๋๋ก ๊ณฑ์
์ญ์, ํ๋ฅด๋ง์ ์์ ๋ฆฌ ํ๊ทธ๋ฅผ ์ฒ์ ๋ณธ ๊ฒ ๊ฐ์๋ค.
- ๋ชจ๋๋ก ๊ณฑ์ ์ญ์๊ณผ ํ๋ฅด๋ง์ ์์ ๋ฆฌ๋ ๋ฌธ์ ์ ์ ์๋ ์ํ ์๋ฆฌ๋ฅผ ์ฌ์ฉํ ๋ฌธ์ ๋ค์ธ ๊ฒ ๊ฐ๋ค.
- ๋ถํ ์ ๋ณต์ ์ด์ฉํ ๊ฑฐ๋ญ์ ๊ณฑ์ ์์์ ๋์จ ๋น ๋ฅธ ๊ฑฐ๋ญ์ ๊ณฑ ์๊ณ ๋ฆฌ์ฆ์ด ๋ถํ ์ ๋ณต์์ ์์ด๋์ด๊ฐ ๋์์ ๊ทธ๋ฐ ๊ฒ ๊ฐ๋ค.
728x90
'CodingTest > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
BOJ_27172 : ์ ๋๋๊ธฐ ๊ฒ์ (0) | 2024.03.12 |
---|---|
BOJ_2166 : ๋ค๊ฐํ์ ๋ฉด์ (0) | 2024.03.11 |
BOJ_11054 : ๊ฐ์ฅ ๊ธด ๋ฐ์ดํ ๋ ๋ถ๋ถ ์์ด (0) | 2024.03.10 |
BOJ_11779 : ์ต์๋น์ฉ ๊ตฌํ๊ธฐ 2 (0) | 2024.03.02 |
BOJ_9935 : ๋ฌธ์์ด ํญ๋ฐ (0) | 2024.03.01 |