Tags
- ๋ฐฑํธ๋ํน
- DP
- Study
- ๊ตฌํ
- Dynamic Programming
- ๋ฌธ์์ด
- ์ํ
- BFS
- ๊ทธ๋ํ ์ด๋ก
- queue
- ๊น์ด ์ฐ์ ํ์
- ๊ต์ฌ
- SpringBoot
- Java
- ๋๋น ์ฐ์ ํ์
- stack
- Brute Force Algorithm
- LV2
- PGM
- sort
- ๊ทธ๋ํ ํ์
- ์๋ฃ๊ตฌ์กฐ
- Python
- dfs
- ์ ๋ ฌ
- greedy
- ์๋ฎฌ๋ ์ด์
- ์ ์๋ก
- CodingTest
- BOJ
Archives
๊ธฐ๋ก๋ฐฉ
BOJ_10986 : ๋๋จธ์ง ํฉ ๋ณธ๋ฌธ
๐ธ ๋ฌธ์ ๋ถ์ ๐ธ
- n๊ฐ์ ์ ๋ ฅ๋๋ ์ซ์์ ๋ถ๋ถ ๊ตฌ๊ฐ ํฉ์ด m์ผ๋ก ๋๋์ด ๋จ์ด์ง๋ ๊ฒฝ์ฐ์ ์๋ฅผ ์ถ๋ ฅํ๋ค.
- n์ 100๋ง, m์ 100์ด๋ค. ๊ตฌ๊ฐ ํฉ์ ๋งค๋ฒ ๊ณ์ฐํ๋ฉด ์๊ฐ์ด ๋ถ์กฑํ๋ฏ๋ก ๊ตฌ๊ฐ ํฉ ๋ฐฐ์ด์ ๋ฏธ๋ฆฌ ๊ณ์ฐํ๋ค.
- ๊ตฌ๊ฐ ํฉ ๋ฐฐ์ด ๊ณต์ : S[i] = S[i-1] + A[i]
- ๋ฐฐ์ด์์ ๊ตฌ๊ฐ ํฉ ๊ตฌํ๊ธฐ ( i ~ j ) : S[j] - S[i-1]
- ๋๋จธ์ง๋ ๋ฏธ๋ฆฌ ๊ณ์ฐํด ๋๋ ๊ฒ์ด ํต์ฌ ์์ด๋์ด
- (A + B) % C == ((A % C) + (B % C)) % C ์ด๋ค.
- S[i] % M == S[j] % M ์ด๋ผ๊ณ ํ๋ฉด, [S[i] - S[j]) % M ์ 0์ด๋ค.
- ์ฆ, ๊ตฌ๊ฐ ํฉ ๋ฐฐ์ด S์ ๊ฐ์ M์ผ๋ก ๋๋ ๋๋จธ์ง๋ก ์ ๋ฐ์ดํธํ๋ฉด, ๊ฐ์ด ๊ฐ์ ์ธ๋ฑ์ค ์์ M์ผ๋ก ๋๋์ด ๋จ์ด์ง๋ค.
๐ธ ์ฝ๋ ๐ธ
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
int n = Integer.parseInt(st.nextToken());
int m = Integer.parseInt(st.nextToken());
long sum[] = new long[n+1];
long c[] = new long[m];
long answer = 0;
st = new StringTokenizer(br.readLine());
for (int i = 1; i <= n; i++){ // ๊ตฌ๊ฐ ํฉ
sum[i] = sum[i-1] + Integer.parseInt(st.nextToken());
}
for (int i = 1; i <= n; i++){ // m์ผ๋ก ๋๋๊ธฐ
int remainder = (int) (sum[i] % m);
if (remainder == 0) answer++;
c[remainder]++;
}
for (int i = 0; i < m; i++){ // ๊ฐ์ ๋๋จธ์ง์์ 2๊ฐ์ ์ธ๋ฑ์ค๋ฅผ ์ ํํ๋ ๊ฒฝ์ฐ์ ์
if (c[i] > 1){
answer += c[i] * (c[i]-1) / 2;
}
}
System.out.println(answer);
}
}
๐ธ ์ฝ๋ ํด์ ๐ธ
- ๊ตฌ๊ฐ ํฉ ๋ฐฐ์ด sum์ ์ธ๋ฑ์ค 1~n ๊น์ง ๊ตฌ๊ฐ ํฉ ๊ฐ์ ์ ์ฅํ๋ค.
- ๋ฐฐ์ด sum์ ์ํํ๋ฉฐ m์ผ๋ก ๋๋ ๋๋จธ์ง๋ฅผ ๊ณ์ฐํ๋ค.
- ๋ฐฐ์ด c์ ๋๋จธ์ง๋ฅผ ์ธ๋ฑ์ค๋ก ํด์ ๊ฐ์ ์ฆ๊ฐ์ํจ๋ค. (๋ฐฐ์ด sum์์ ๊ฐ์ ๋๋จธ์ง๋ฅผ ๊ฐ๋ ์ธ๋ฑ์ค ์)
- ๋๋จธ์ง๊ฐ 0์ด๋ฉด 0~ํด๋น ์ธ๋ฑ์ค๊น์ง์ ๊ตฌ๊ฐ ํฉ์ด m์ผ๋ก ๋๋์ด ๋จ์ด์ง๋ค๋ ๊ฒ์ด๋ฏ๋ก answer์ ์ฆ๊ฐ์ํจ๋ค.
(์ธ๋ฑ์ค 0~i์ ๊ตฌ๊ฐ ํฉ์ ๊ณต์์ผ๋ก ๋ํ๋์ง ์์ผ๋ฏ๋ก ๋ฐ๋ก ๊ณ์ฐํด์ค์ผ ํ๋ค)
- ๊ฐ์ ๋๋จธ์ง์ ์ธ๋ฑ์ค๋ค์์ ์์ ๋ง๋๋ ๊ฒฝ์ฐ์ ์๋ฅผ answer์ ๋ํ๋ค.
- C[i] ๊ฐ์์ 2๊ฐ๋ฅผ ๊ณ ๋ฅด๋ ๊ฒจ์ฐ์ ์ : C[i] * (C[i] - 1) / 2
๐ธ end ๐ธ
- ๊ณจ๋ 3๋ฌธ์ ๋ ์ฒ์ ํ์ด๋ดค๋๋ฐ ์๋นํ ์ด๋ ค์ด ๊ฒ ๊ฐ๋ค. ๊ต์ฌ๋ฅผ ๋ณด๋ฉฐ ํ์ด๋ฅผ ๋ณด๋ฉด์๋ ์ดํดํ๋๋ฐ ์๊ฐ์ด ๊ฑธ๋ ธ๋ค.
- ๊ตฌ๊ฐ ํฉ ๋ง์ผ๋ก๋ ์ด๋ ๊ฒ ์ด๋ ค์ด ๋ฌธ์ ๊ฐ ๋ง๋ค์ด์ง๋๊ฒ ์ ๊ธฐํ๋ค.
- ๊ตฌ๊ฐ ํฉ์ผ๋ก ๊ณจ๋ 3๊น์ง ํ์ด๋ดค์ผ๋ ์ด๋์ ๋ ์์ ๊ฐ์ด ์๊ธฐ๋ ๊ฒ ๊ฐ๋ค.
- ๊ธฐ์กด์ ๋ด ํ์ด์์๋ ๊ตฌ๊ฐ ํฉ ๋ฐฐ์ด์ ๊ตฌํ๊ณ , ๊ตฌ๊ฐํฉ์์ m์ ๋๋จธ์ง๋ฅผ ๋งค๋ฒ ๊ณ์ฐํ๋ ์์ผ๋ก ํ๋๋ฐ ์๊ฐ ์ด๊ณผ๊ฐ ๋ฌ๋ค.
- ๊ทธ ๋ค์์ ๋ฏธ๋ฆฌ ๋๋จธ์ง๋ก ๊ณ์ฐํ๊ณ , ๊ฐ์ด ๊ฐ์ ๊ฒฝ์ฐ๋ฅผ ์ด์ค ๋ฐ๋ณต๋ฌธ์ผ๋ก ์ฐพ๋๋ฐ ๋ ์๊ฐ ์ด๊ณผ๊ฐ ๋ฌ๋ค.
- ๊ฐ์ ๋๋จธ์ง๋ค์ ์๋ฅผ ๊ตฌํ๊ณ , 2๊ฐ๋ฅผ ๋ง๋ค ์ ์๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ณ์ฐํด์ผ ํ๋ค.
- ๊ทธ๋ฅ ํ์ด ์์ฒด๋ ๊ตฌ๊ฐ ํฉ์ ๋ฏธ๋ฆฌ ๋๋จธ์ง๋ฅผ ๊ณ์ฐํ๋ค๋๊ฒ ์ ๊ธฐํ๋๋ฐ, ๋๋จธ์ง๋ฅผ ๋ฏธ๋ฆฌ ์ธ๊ณ ์์ ๋ง๋๋ ์กฐํฉ์ ์๋ฅผ ๊ณ์ฐํ๋ ๊ฑด ์๊ฐ๋ ๋ชปํ๋ค. ์์ ์ ๋ฐฐ์ด ์ํ ๊ณต์์ธ๋ฐ ์ฐธ ๋ฏ์ค๋ค...
728x90
'CodingTest > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
BOJ_1940 : ์ฃผ๋ชฝ (0) | 2022.09.24 |
---|---|
BOJ_2018 : ์๋ค์ ํฉ 5 (0) | 2022.09.24 |
BOJ_1384 : ๋ฉ์์ง (0) | 2022.09.23 |
BOJ_11669 : ๊ตฌ๊ฐ ํฉ ๊ตฌํ๊ธฐ 5 (0) | 2022.09.22 |
BOJ_1380 : ๊ท๊ฑธ์ด (0) | 2022.09.22 |