To Do
- ์ธ์ ๋ฆฌ์คํธ๋?
- ๊ฐ์ค์น๊ฐ ์๋ ๊ทธ๋ํ๋ฅผ ์ธ์ ๋ฆฌ์คํธ๋ก ๊ตฌํํ๊ธฐ
- ๊ฐ์ค์น๊ฐ ์๋ ๊ทธ๋ํ๋ฅผ ์ธ์ ๋ฆฌ์คํธ๋ก ๊ตฌํํ๊ธฐ
์ง๋ ์๊ฐ์ ์ฐ๋ฆฌ๋ ์ธ์ ํ๋ ฌ๋ก ๊ทธ๋ํ๋ฅผ ๊ทธ๋ฆฌ๋ ์๊ฐ์ ๊ฐ์ก๋ค.
์ค๋์ ๊ทธ๋ํ๋ฅผ ๊ทธ๋ฆฌ๋ ๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ธ ์ธ์ ๋ฆฌ์คํธ๋ก ๊ทธ๋ํ๋ฅผ ๊ทธ๋ ค๋ณด์.
์ธ์ ๋ฆฌ์คํธ
Adjancency List ์ธ์ ๋ฆฌ์คํธ๋
ํ ๋ ธ๋์ ์ฐ๊ฒฐ ์ํ๋ฅผ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ก ๊ตฌํํ ๊ฒ์ ์๋ฏธํ๋ค.
์ฐ๋ฆฌ๊ฐ ์๊น ์์์ ๋ง๋ค์ด ๋จ๋ ์์์ ๊ทธ๋ํ๋ฅผ ํ ๋๋ก ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ก ๋ง๋ค์ด๋ณด์.
๋ ธ๋๊ฐ 6๊ฐ๊ฐ ์์ผ๋ฏ๋ก 1๋ฒ ๋ ธ๋๋ถํฐ ๊ด๊ณ๋ฅผ ์ฐพ์๋ณด์
1 -> 2
2 -> 1 - 3 - 4
3 -> 2 - 4 - 5
4 -> 3 - 5 - 6
5 -> 3 - 4
6 -> 4
๊ด๊ณ๋ฅผ ์ฐพ์์ผ๋ ์ด์ ๊ฐ ๋ ธ๋์ ํด๋นํ๋ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ฅผ ๋ง๋ค์ด๋ณด์.
์์ค ์ฝ๋
์ฐ๋ฆฌ๋ ์ธ์ ๋ฆฌ์คํธ๋ฅผ ์ฃผ๋ก ๊ทธ๋ํ์์ ๋ง์ด ์ธ ์์ ์ด๋ค.
๊ทธ๋ํ์๋ ์ฌ๋ฌ ์ข ๋ฅ๊ฐ ์๊ฒ ์ง๋ง ์กฐ๊ธ ํฌ๊ฒ ๋๋์๋ฉด 2๊ฐ์ง ์ข ๋ฅ๊ฐ ์๋ค.
1. ๊ฐ์ค์น๊ฐ ์๋ ๊ทธ๋ํ
2. ๊ฐ์ค์น๊ฐ ์๋ ๊ทธ๋ํ
์ด ๋ ๋ฒ์ ๋ชจ๋ ๊ตฌํ์ ํด๋ณด๊ฒ ๋ค.
๊ฐ์ค์น๊ฐ ์๋ ๊ทธ๋ํ
import java.io.*;
import java.util.ArrayList;
public class Main {
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 n = 4 // ์ ์ ์ ๊ฐ์ == ๋
ธ๋ ๊ฐฏ์
int m = 5 // ๊ฐ์ ์ ๊ฐ์
// ์ธ์ ๋ฆฌ์คํธ
ArrayList<ArrayList<Integer>> graph = new ArrayList<>();
// ์ธ์ ๋ฆฌ์คํธ๋ก ๊ตฌ์ฑํ ๊ทธ๋ํ์ ArrayList๋ฅผ ๋ฃ์ด์ฃผ๋ฉด์ ์ด๊ธฐํ
for (int i = 0; i <= n; i++) {
graph.add(new ArrayList<>());
}
/** ์
๋ ฅ ์์
* 1 2
* 1 3
* 1 4
* 2 4
* 3 4
*/
for (int i = 0; i < m; i++) {
String[] nv = br.readLine().split(" ");
int n1 = Integer.parseInt(nv[0]);
int n2 = Integer.parseInt(nv[1]);
graph.get(n1).add(n2);
graph.get(n2).add(n1);
}
1๋ฒ ์ธ์ ๋ฆฌ์คํธ์์ 4๋ฒ ์ธ์ ๋ฆฌ์คํธ๊น์ง ์ถ๋ ฅ
for(int i = 1; i <= 4; i++){
bw.write(graph.get(i).toString());
}
bw.flush();
bw.close();
}
}
// ์ถ๋ ฅ : [2, 3, 4][1, 4][1, 4][1, 2, 3]
์ด๋ ๊ฒ ๊ฐ์ค์น๊ฐ ์๋ ๊ทธ๋ํ๋ ์ธ์ ๋ฆฌ์คํธ๋ฅผ ํ๋ ์์ฑํ๊ณ ๋ ธ๋์ ๊ฐ์๋งํผ ๋ฐ๋ณต์ ๋๋ฉฐ ArrayList ๊ฐ์ฒด ํ ๋น์ ํด์ค๋ค.
๊ทธ๋ฆฌ๊ณ ๊ฐ์ ์ ์ ๋งํผ ๋ฐ๋ณต์ ๋ ๋๋ฉฐ ๊ทธ๋ํ ์ฐ๊ฒฐ ์ํ๋ฅผ ์ ๋ ฅ ๋ฐ๊ณ ๊ฐ๊ฐ์ ๊ทธ๋ํ์ ์ถ๊ฐํด์ค๋ค.
์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ํ์ด์์ ์์ฃผ ์ฌ์ฉ๋๋ BufferedReader์ Writer๋ก ๊ตฌํ์ ํด๋ณด์๋ค.
๊ฐ์ค์น๊ฐ ์๋ ๊ทธ๋ํ
import java.util.ArrayList;
import java.util.Scanner;
class Edge<W, V> {
private W weight;
private V v;
public void setEdge(W weight, V v) {
this.weight = weight;
this.v = v;
}
}
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = 4; // ๋
ธ๋์ ๊ฐฏ์
int m = 5; // ๊ฐ์ ์ ๊ฐฏ์
ArrayList<Edge<Integer, Integer>> graph = new ArrayList<>();
for (int i = 0; i < n; i++) {
graph.add(new Edge<>());
}
for (int i = 0; i < m; i++) { // ๊ฐ์ ์ ๊ฐฏ์๋งํผ ๋ฐ๋ณต
int n1 = input.nextInt(); // ๋
ธ๋ 1
int n2 = input.nextInt(); // ๋
ธ๋ 2
int weight = input.nextInt();
graph.get(n1).setEdge(n2, weight);
graph.get(n2).setEdge(n1, weight);
}
}
}
๊ฐ์ค์น๊ฐ ์๋ ๊ทธ๋ํ์๋ ์ฐ๋ฆฌ์ ์ธ์ ๋ฆฌ์คํธ์ ์ฐ๊ฒฐ๋ ๊ทธ๋ํ ๋ฟ๋ง ์๋๋ผ ๊ทธ์ ๋ํ ๊ฐ์ค์น๋ ๋ฃ์ด์ผ ํ๊ธฐ ๋๋ฌธ์ Edge ํด๋์ค๋ฅผ ์๋กญ๊ฒ ๋ง๋ค์ด์ค๋ค.
๊ทธ Edge ํด๋์ค์๋ ๊ฐ์ค์น์ ๋ ธ๋ ๋ฒํธ๊ฐ ๋ค์ด๊ฐ๊ฒ ๋๋ค.
์ด๋ฒ์๋ ์๋ฐ์์ ์ผ๋ฐ์ ์ผ๋ก ๋ง์ด ์ฌ์ฉ๋๋ Scanner ๋ก ์ ์ถ๋ ฅ์ ์ฒ๋ฆฌํด๋ณด์๋ค.
ํน์ง
ํน์ง | ๊ณต๊ฐ ๋ณต์ก๋ | |
์ธ์ ๋ฆฌ์คํธ | ํน์ ์ ์ ์ ์ ๊ทผํ๋ ค๋ฉด ์ฐ๊ฒฐ๋ ๋ชจ๋ ์ ์ ๋ฐฉ๋ฌธํด์ผํจ | v๋ผ๋ ๊ฐ์ ์ ์๋ O(V+E) |
๋๊ธ