๋ฐฑ์ค 5237๋ฒ, Connected or Not Connected (with.Java)
๋ฐฑ์ค 5237๋ฒ Connected or Not Connected (with.Java) ์ ๋ํ์ฌ ์์๋ณธ ๊ธ์ ๋๋ค.
์ฝ๋ฉ ํ ์คํธ ๋ฌธ์ ๋ฅผ ํ๋ฉฐ, ํ์๋ ๋ฌธ์ ์ ๋ํ ํ๊ณ ์ ๋ค๋ฅธ ํ์ด ๋ฐฉ๋ฒ์ ์์๋ณด๋ฉฐ, ์์๊ฐ๊ณ ์ ํฉ๋๋ค.
๋ฌธ์ ์ ๋ํด ๋จผ์ ์์๋ณด๊ฒ ์ต๋๋ค.
๋ฌธ์
Sam๊ณผ Quorra๋ (๊ฐ์) ๊ฒฝ๋ก๋ก ์ํธ ์ฐ๊ฒฐ๋ ์ฌ๋ฌ (๊ฐ์) ์ฌ์ดํธ๋ฅผ ํฌํจํ๋ Grid ์ธ๊ณ์ ๋น๋ฐ ๊ธฐ์ง ์ง๋๋ฅผ ๊ตฌ์ถํ๋ ค๊ณ ๋ ธ๋ ฅํ๊ณ ์์ต๋๋ค.
๊ทธ๋ค์ ์ฌ์ดํธ ์(n)๋ฅผ ์๊ณ ์์ง๋ง, ์ฌ์ดํธ ๊ฐ์ ์ํธ ์ฐ๊ฒฐ์ ๋ํ ์ง์์ ๋ถ์กฑํฉ๋๋ค.
๊ธฐ์ง ๋ด์ ์๋ ์ฌ๋ฌ ๋ค๋ฅธ ํ๋ก๊ทธ๋จ๋ค์ ์ฌ์ดํธ ๊ฐ์ ์ฐ๊ฒฐ์ ๋ํ ์ ๋ณด๋ฅผ ์ ๊ณตํ ์ ์์ผ๋ฉฐ, Sam๊ณผ Quorra๋ ์ด๋ฅผ ์ข ํฉํด์ผ ํฉ๋๋ค.
ํนํ, ๊ทธ๋ค์ ๋ชจ๋ ์ฌ์ดํธ์์ ๋ค๋ฅธ ๋ชจ๋ ์ฌ์ดํธ๋ก ์ด๋ํ๋ ๋ฐฉ๋ฒ์ ์ ์ ์๋ ์ถฉ๋ถํ ์ ๋ณด๋ฅผ ๊ฐ์ง๊ณ ์๋์ง ํ์ธํ๊ณ ์ ํฉ๋๋ค.
๊ทํ์ ๋ชฉํ๋ ์ง์ ๋ ์ฐ๊ฒฐ ์ธํธ๊ฐ ๋ชจ๋ ์ฌ์ดํธ์์ ๋ค๋ฅธ ์ฌ์ดํธ๋ก ๊ฐ๋ ๊ฒฝ๋ก๋ฅผ ํ๋ณดํ๊ธฐ์ ์ถฉ๋ถํ์ง ์ฌ๋ถ๋ฅผ ๊ฒฐ์ ํ๋ ๋ฐ ๋์์ ์ฃผ๋ ๊ฒ์ ๋๋ค.
์ฐ๊ฒฐ์ด ์๋ฐฉํฅ์ด๋ผ๊ณ ๊ฐ์ ํฉ๋๋ค.
์ฆ, ์ฌ์ดํธ 1๊ณผ ์ฌ์ดํธ 2 ์ฌ์ด์ ์ฐ๊ฒฐ์ด ์๋ค๋ ๊ฒ์ ์๊ณ ์๋ค๋ฉด ์ฌ์ดํธ 1์์ ์ฌ์ดํธ 2๋ก, ๋๋ ๊ทธ ๋ฐ๋๋ก ์ด๋ํ ์ ์์ต๋๋ค.
์ ๋ ฅ
ํ ์คํธ ๋ฐ์ดํฐ ํ์ผ์ ์ฒซ ๋ฒ์งธ ์ค์๋ ํ ์คํธ ์ผ์ด์ค์ ์(โค 50)๊ฐ ํฌํจ๋์ด ์์ต๋๋ค.
๊ทธ ํ ๊ฐ ์ค์๋ ํ ์คํธ ์ผ์ด์ค๊ฐ ํฌํจ๋ฉ๋๋ค.
๊ฐ ํ ์คํธ ์ผ์ด์ค์ ์ฒซ ๋ฒ์งธ ์ซ์๋ ์ฌ์ดํธ์ ์, n(โค 100)์ ๋๋ค.
์ฌ์ดํธ๋ 0์์ n - 1๊น์ง ๋ฒํธ๊ฐ ๋งค๊ฒจ์ง๋๋ค.
๋ ๋ฒ์งธ ์ซ์๋ ์ฌ์ดํธ ๊ฐ์ ์ฐ๊ฒฐ ์, k(โค 200)์ ๋๋ค.
๊ทธ ํ ๊ฐ ์ฐ๊ฒฐ๋ง๋ค ํ๋์ฉ k์์ ์ซ์๊ฐ ์์ต๋๋ค. ์ฐ๊ฒฐ์ด ๋ฐ๋ณต๋ ์ ์์ผ๋ฉฐ, ๋ ๋์๊ฐ ์์ฒด ์ฐ๊ฒฐ (์ฆ, ์ฌ์ดํธ์์ ์์ฒด๋ก์ ์ฐ๊ฒฐ)์ด ์์ ์ ์์ต๋๋ค.
์ถ๋ ฅ
๊ฐ ํ ์คํธ ์ผ์ด์ค๋ง๋ค ๋ชจ๋ ์ฌ์ดํธ์์ ๋ค๋ฅธ ์ฌ์ดํธ๋ก ๊ฐ๋ ๊ฒฝ๋ก๊ฐ ์๋์ง ํ์ธํ๊ณ , ์ด์ ๋ฐ๋ผ โ์ฐ๊ฒฐ๋จโ ๋๋ โ์ฐ๊ฒฐ๋์ง ์์โ์ ์ถ๋ ฅํด์ผ ํฉ๋๋ค.
๋ฌธ์ ํ์ด
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 = 0; i < T; i++){
StringTokenizer st = new StringTokenizer(br.readLine());
int N = Integer.parseInt(st.nextToken());
int K = Integer.parseInt(st.nextToken());
List<Integer>[] graph = new ArrayList[N];
for(int j = 0; j < N; j++){
graph[j] = new ArrayList<>();
}
for(int j = 0; j < K; j++){
int u = Integer.parseInt(st.nextToken());
int v = Integer.parseInt(st.nextToken());
graph[u].add(v);
graph[v].add(u);
}
boolean[] visited = new boolean[N];
dfs(0, graph, visited);
boolean isConnected = true;
for(int j = 0; j < N; j++){
if(!visited[j]){
isConnected = false;
break;
}
}
sb.append(isConnected ? "Connected.\n" : "Not connected.\n");
}
System.out.print(sb);
}
private static void dfs(int node, List<Integer>[] graph, boolean[] visited){
visited[node] = true;
for(int next : graph[node]){
if(!visited[next]){
dfs(next, graph, visited);
}
}
}
}
ํ์ด ์ค๋ช
์ด ์ฝ๋๋ ์ฃผ์ด์ง ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ์์ ๋ชจ๋ ๋ ธ๋๊ฐ ์๋ก ์ฐ๊ฒฐ๋์ด ์๋์ง๋ฅผ ํ์ธํ๋ ํ๋ก๊ทธ๋จ์ ๋๋ค.
๋จผ์ , BufferedReader๋ฅผ ์ฌ์ฉํ์ฌ ์ ๋ ฅ์ ๋น ๋ฅด๊ฒ ์ฝ์ด์ค๋ฉฐ ์ฒซ ๋ฒ์งธ ์ ๋ ฅ๊ฐ์ผ๋ก ํ ์คํธ ์ผ์ด์ค ๊ฐ์ T๋ฅผ ๋ฐ์ต๋๋ค.
์ดํ, ๊ฐ ํ ์คํธ ์ผ์ด์ค๋ง๋ค ๋ ธ๋ ๊ฐ์ N๊ณผ ๊ฐ์ ๊ฐ์ K๋ฅผ ์ ๋ ฅ๋ฐ์ต๋๋ค.
๊ทธ๋ํ๋ ์ธ์ ๋ฆฌ์คํธ ๋ฐฉ์์ผ๋ก ํํ๋๋ฉฐ, List
์ดํ K๊ฐ์ ๊ฐ์ ์ ๋ณด๋ฅผ ์ฝ์ด์ ํด๋น ๋ ธ๋ ์์ ์๋ก ์ถ๊ฐํ์ฌ ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ๋ฅผ ํ์ฑํฉ๋๋ค.
๊ทธ๋ํ๊ฐ ์์ฑ๋๋ฉด DFS(๊น์ด ์ฐ์ ํ์)๋ฅผ ์ด์ฉํด ๋ชจ๋ ๋ ธ๋๋ฅผ ํ์ํฉ๋๋ค.
๋ฐฉ๋ฌธ ์ฌ๋ถ๋ฅผ ํ์ธํ๊ธฐ ์ํด boolean ๋ฐฐ์ด visited๋ฅผ ์ ์ธํ๊ณ , dfs(0, graph, visited) ํจ์๋ฅผ ํธ์ถํ์ฌ 0๋ฒ ๋ ธ๋๋ถํฐ ํ์์ ์์ํฉ๋๋ค.
DFS ํจ์๋ ํ์ฌ ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธ ์ฒ๋ฆฌํ ํ ์ธ์ ํ ๋ ธ๋๋ค์ ํ์ธํ๋ฉฐ ๋ฐฉ๋ฌธํ์ง ์์ ๊ฒฝ์ฐ ์ฌ๊ท ํธ์ถ์ ํตํด ํ์์ ๊ณ์ ์งํํฉ๋๋ค.
ํ์์ด ๋๋ ํ visited ๋ฐฐ์ด์ ํ์ธํ๋ฉฐ, ํ๋๋ผ๋ false์ธ ๋ ธ๋๊ฐ ์์ผ๋ฉด ๋ชจ๋ ๋ ธ๋๊ฐ ์ฐ๊ฒฐ๋์ง ์์ ๊ฒ์ผ๋ก ํ๋จํ์ฌ ์ฐ๊ฒฐ๋์ง ์์์ ์ถ๋ ฅํ๊ณ , ๋ชจ๋ ๋ ธ๋๊ฐ ๋ฐฉ๋ฌธ๋์๋ค๋ฉด ์ฐ๊ฒฐ๋จ์ ์ถ๋ ฅํฉ๋๋ค.
๋ง์ง๋ง์ผ๋ก StringBuilder๋ฅผ ์ฌ์ฉํ์ฌ ๊ฒฐ๊ณผ๋ฅผ ํ ๋ฒ์ ์ถ๋ ฅํจ์ผ๋ก์จ ์ฑ๋ฅ์ ์ต์ ํํฉ๋๋ค.