Tags
- ๊ต์ฌ
- Study
- ์๋ฎฌ๋ ์ด์
- stack
- Brute Force Algorithm
- ์ ์๋ก
- queue
- Java
- ๊น์ด ์ฐ์ ํ์
- Dynamic Programming
- sort
- PGM
- ๊ทธ๋ํ ์ด๋ก
- ๋๋น ์ฐ์ ํ์
- CodingTest
- ์๋ฃ๊ตฌ์กฐ
- BFS
- Python
- ๋ฐฑํธ๋ํน
- ๊ทธ๋ํ ํ์
- ๋ฌธ์์ด
- dfs
- ๊ตฌํ
- greedy
- DP
- ์ํ
- BOJ
- SpringBoot
- ์ ๋ ฌ
- LV2
Archives
๊ธฐ๋ก๋ฐฉ
BOJ_1976 : ์ฌํ ๊ฐ์ ๋ณธ๋ฌธ
๐ธ ๋ฌธ์ ๋ถ์ ๐ธ
- N๊ฐ์ ๋์ ์ค M๊ฐ์ ๋์๋ฅผ ์ฌํํ๊ณ ์ ํ๋ค.
- ๊ฒฝ๋ก๊ฐ ์์ด์ ์ฌํ์ด ๊ฐ๋ฅํ๋ฉด YES, ๋ถ๊ฐ๋ฅํ๋ฉด NO๋ฅผ ์ถ๋ ฅํ๋ค.
๐ธ ๋ฌธ์ ํ์ด ๐ธ
- ์ฌํ ํ๊ณ ์ ํ๋ M๊ฐ์ ๋์ ๊ฐ์ ๊ฒฝ๋ก๊ฐ ์๋์ง ํ์
ํ๋ ์ฌ์ด ๋ฐฉ๋ฒ์ ๊ฐ์ ์งํฉ์ ์๋์ง ํ์ธํ๋ ๊ฒ์ด๋ค.
- ๋ถ๋ฆฌ ์งํฉ(Disjoint Set)์ผ๋ก N๊ฐ์ ๋์๋ค์ ์งํฉ์ ๋๋๋ค.
- ์ฌํ ๊ณํ์์ ๋์๋ค์ด ๊ฐ์ ์งํฉ์ ์์ผ๋ฉด ๊ฒฝ๋ก๊ฐ ์กด์ฌํ๋ค๋ ๋ป์ด๋ค.
- ๋ถ๋ฆฌ ์งํฉ์ด ์๋๋ผ BFS๋ DFS๋ก Brute Force ์๊ณ ๋ฆฌ์ฆ ํ์์ ์งํํ๋ค๋ฉด, N์ด 200์ด๊ณ M์ด 1000 ์ด๋ฉด์ 1์ํ ๊ทธ๋ํ์ด๊ณ ๋์์ ๋์ ์ค๊ณ ๊ฐ๋ค๋ฉด 200^1000์ด๋ผ๋ ๋ง๋ ์๋๋ ์๊ฐ ๋ณต์ก๋๊ฐ ๋์จ๋ค.
- ๋ถ๋ฆฌ ์งํฉ์ ์๊ฐ ๋ณต์ก๋๋ O(logN) ์ด๋ฏ๋ก ๊ฐ๋จํ ํด๊ฒฐ๋๋ค.
- ๊ฒฝ๋ก ์ ๋ฌด๊ฐ N * N ์ธ์ ํ๋ ฌ๋ก ์ฃผ์ด์ง๋๋ฐ, ๊ฒฝ๋ก๊ฐ ์๋ค๋ 1 ์ ๋ ฅ ์ union ์ฐ์ฐ์ ์ํํ๋ค.
- ๋ง์ง๋ง M๊ฐ์ ์ฌํ ๊ฒฝ๋ก๊ฐ ๊ฐ์ ์งํฉ์ ์๋์ง find ์ฐ์ฐ์ ์ํํ๋ค.
๐ธ ์ฝ๋ ๐ธ
import java.io.*;
import java.util.StringTokenizer;
public class Main {
private static int[] parent;
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
StringTokenizer st = null;
int N = Integer.parseInt(br.readLine());
int M = Integer.parseInt(br.readLine());
parent = new int[N + 1];
for (int i = 1; i <= N; i++) {
parent[i] = i;
}
for (int i = 1; i <= N; i++) {
st = new StringTokenizer(br.readLine());
for (int j = 1; j <= N; j++) {
int a = Integer.parseInt(st.nextToken());
if (a == 1) {
union(i, j);
}
}
}
st = new StringTokenizer(br.readLine());
int set_parent = find(Integer.parseInt(st.nextToken()));
String answer = "YES";
for (int i = 1; i < M; i++) {
if (set_parent != find(Integer.parseInt(st.nextToken()))) {
answer = "NO";
break;
}
}
bw.write(answer);
bw.flush();
}
private static int find(int a) {
if (parent[a] == a) {
return a;
}
return parent[a] = find(parent[a]);
}
private static boolean union(int a, int b) {
int ap = find(a);
int bp = find(b);
if (ap != bp) {
parent[ap] = bp;
return true;
}
return false;
}
}
๐ธ ์ฝ๋ ํด์ ๐ธ
- ๋ถ๋ฆฌ ์งํฉ์ ์ํด union(), find() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋๋ฐ, union() ๋ฉ์๋์ ๋ฐํ๊ฐ์ ์ฌ์ฉ๋์ง ์์ผ๋ฏ๋ก boolean์ด ์๋๋ผ void ๊ฐ ๋์ด๋ ์๊ด ์๋ค.
- ๋ถ๋ฆฌ ์งํฉ์ ๋ชจ๋ ์ํํ ํ, ์ฌํ ๊ฒฝ๋ก ์ฒซ ๋ฒ์งธ ๋์์ ๋ถ๋ชจ ๋
ธ๋ ๋ฒํธ๋ฅผ ํ์ธํ ๋ค, ๋ค์ ์ฌํ ๊ฒฝ๋ก ๋์๋ค์ ๋ถ๋ชจ ๋
ธ๋ ๋ฒํธ์ ๊ฐ์์ง ํ์ธํ๋ค.
- ๋ชจ๋ ๊ฐ์ผ๋ฉด YES, ํ๋๋ผ๋ ๋ค๋ฅด๋ฉด NO๋ฅผ ์ถ๋ ฅํ๋ค.
๐ธ end ๐ธ
- ๋ถ๋ฆฌ ์งํฉ์ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ์ ํํ๋ฉด ์ฝ๊ฒ ํ ์ ์๋ ๋ฌธ์ ์๋ค.
728x90
'CodingTest > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
BOJ_2573 : ๋น์ฐ (0) | 2024.04.27 |
---|---|
BOJ_14499 : ์ฃผ์ฌ์ ๊ตด๋ฆฌ๊ธฐ (0) | 2024.04.26 |
BOJ_2580 : ์ค๋์ฟ (0) | 2024.04.19 |
BOJ_1707 : ์ด๋ถ ๊ทธ๋ํ (0) | 2024.04.13 |
BOJ_3190 : ๋ฑ (0) | 2024.04.11 |