๐ ๋ฌธ์ ๋งํฌ
๐ ๋ฌธ์ ํ์ด
ํธ๋ฆฌ๋ฅผ ์ํํ๋ฉด ๋๋ค. ์ด ๋ฌธ์ ๋ ์ขํ ๊ฐ์ผ๋ก ์ฃผ์ด์ง๋ ๋ ธ๋๋ค์ ํธ๋ฆฌ๋ก ๊ตฌ์ฑํด์ผํ๋ค๋ ์ ์ด ํต์ฌ์ด๋ค.
์ด๋ฐ ์ ํ์ ๋ฌธ์ ๋ ์ฒ์์ด๋ผ ,, ํธ๋ฆฌ์ ๋ํด ๊ฐ๋จํ ์ ๋ฆฌํ๋ฉด์ ์ดํดํ๋ค.
ํธ๋ฆฌ (Tree)
๐ฆ ํฌ๋ฆฌ์ค๋ง์ค D-10 ๊ธฐ๋ ์ผ๋ก ํธ๋ฆฌ์ ๋ํด์ ์์๋ณด์ ๐ ๐ป ๋ฌผ๋ก ํฌ๋ฆฌ์ค๋ง์ค ํธ๋ฆฌ ๋ง๊ณ ,, ์๋ฃ๊ตฌ์กฐ ํธ๋ฆฌ์ด๋ค ^_^ ํธ๋ฆฌ๋ ๊ฐ๊ณ๋์ ๊ฐ์ ๊ณ์ธต์ ์ธ ๊ตฌ์กฐ๋ฅผ ํํํ ๋ ์ฌ์ฉํ ์ ์๋ ์๋ฃ๊ตฌ์กฐ์ด
suebin-log.tistory.com
ํธ๋ฆฌ๋ฅผ ์ํํ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ฝ๋๋ง ์ฒ์ ๋ฑ ๋ณด์์ ๋๋ ์ด๋ ต๋ค๊ณ ๋๊ผ๋๋ฐ,
ํธ๋ฆฌ์ ๋ํด ์ดํดํ๊ณ ๋ค์ ๋ณด๋ ์ง๊ด์ ์ด๋ผ์ ์คํ๋ ค ์ดํดํ๊ธฐ๊ฐ ์ฌ์ ๋ค.
๊ทธ๋ฆฌ๊ณ ์ด ๋ฌธ์ ์์ ํธ๋ฆฌ๋ฅผ ๋ง๋๋ ๊ณผ์ ์ ๋ค์๊ณผ ๊ฐ๋ค.
1) x ์ขํ, y ์ขํ, ๋ ธ๋ ๋ฒํธ(=value), ์ผ์ชฝ ์์,๋ ธ๋ ์ค๋ฅธ์ชฝ ์์ ๋ ธ๋๋ฅผ ์ ์ฅํ ์ ์๋๋ก Node ํด๋์ค๋ฅผ ๋ง๋ ๋ค.
2) ์กฐ๊ฑด์ ๋ง๋ ํธ๋ฆฌ ๊ตฌ์กฐ๋ก ๋ง๋ค๊ธฐ ์ํด Comparator ์ธํฐํ์ด์ค๋ฅผ ํ์ฉํด ์ ๋ ฌํ๋ค.
• y ๊ฐ์ ๋ ํฐ ๊ฐ์ด ๋จผ์ ์ค๋๋ก, y ๊ฐ์ด ๊ฐ๋ค๋ฉด x ๊ฐ์ด ๋ ์์ ๊ฐ์ด ๋จผ์ ์ค๋๋ก ํ๋ค.
3) ์ ๋ ฌ ํ 0๋ฒ ์ธ๋ฑ์ค ๊ฐ์ root๋ก ์ง์ ํ๊ณ , root๋ฅผ ๊ธฐ์ค์ผ๋ก ๋ ธ๋๋ฅผ insert ํ๋ค.
ํธ๋ฆฌ๋ฅผ ๋ง๋ค์์ผ๋ฉด ์ฌ๊ท๋ฅผ ํ์ฉํด ์ ์ ์ํ์ ํ์ ์ํ๋ฅผ ํด์ฃผ๋ฉด ๋๋ค.
ํนํ, ํธ๋ฆฌ๋ฅผ ๋ง๋ค๊ธฐ ์ํด Node ํด๋์ค๋ฅผ ๊ฐ์ฒด ๋ฐฐ์ด๋ก ์ ์ธํ๋ ๋ถ๋ถ์์ ๊ฐ์ฒด ๋ฐฐ์ด์ ๋ํด ์๋กญ๊ฒ ๋ฐฐ์ ๋ค.
๋ง์ฐฌ๊ฐ์ง๋ก Node ํด๋์ค๋ฅผ ๋ณ์๋ก ์ ์ธํ๋ ๊ฒ๋ ์๋ก์ ๋ค. ์ด๋ฐ ๊ฒฝ์ฐ๋ ์ฐธ์กฐ๋ณ์๋ก๋ง ์ธ ์๊ฐ ์๋ค๊ณ ํ๋ค.
Kakao Tech ๋ธ๋ก๊ทธ ๋ฌธ์ ํด์ค์ ๋ณด๋ ์ด ๋ฌธ์ ์ ๋ต๋ฅ ์ด 7.4% ์ด๋ค ,,
์๋ฆฌ๋ ์ดํดํ์ง๋ง, ๋ง์ ๋ฌธ์ ๋ฅผ ๋ง์ฃผ์น๋ฉด ๋นํฉํ ๊ฒ ๊ฐ๋ค.
ํธ๋ฆฌ ์ํ ์๊ณ ๋ฆฌ์ฆ๋ ๋ฐฑ์ค์์ ๋ช ๊ฐ ๋ ํ์ด๋ด์ผ๊ฒ ๋ค !
ํด๋น ๋ฌธ์ ํ์ด๋ ๊ฐ์ฒด ๋ฐฐ์ด์ ๋ง๋๋ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ์ง๋ง !
Kakao Tech์์๋ Queue๋ฅผ ๋ง๋ค์ด x์ถ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ๋ ๋ ธ๋๋ค์ y์ถ ๊ฐ์ด ๊ฐ์ ๋ ธ๋๋ผ๋ฆฌ ๊ฐ Queue์ ๋ฃ์ด๋๊ณ , Queue์ front๋ฅผ ํ์ธํ๋ ๋ฐฉ๋ฒ์ ์๋ ค์ค๋ค.
Key Point
๐ ์ขํ ๊ฐ์ผ๋ก ์ฃผ์ด์ง๋ ๋ ธ๋๋ค์ ํธ๋ฆฌ๋ก ๊ตฌ์ฑํ๋ค.
๐ ํธ๋ฆฌ ์ํ ์๊ณ ๋ฆฌ์ฆ์ ํ์ฉํ๋ค.
๐ ์ ์ ์ํ๋ ๋ ธ๋ - ์ผ์ชฝ ์์ - ์ค๋ฅธ์ชฝ ์์ ์์ด๊ณ , ํ์ ์ํ๋ ์ผ์ชฝ ์์ - ์ค๋ฅธ์ชฝ ์์ - ๋ ธ๋ ์์ด๋ค.
Java ์ฝ๋
import java.util.*;
class Solution {
int[][] answer;
int idx;
public int[][] solution(int[][] nodeinfo) {
// ๋
ธ๋๋ฅผ ์
๋ ฅ๋ฐ๋๋ค.
Node[] node = new Node[nodeinfo.length];
for (int i=0; i<nodeinfo.length; i++) {
node[i] = new Node(nodeinfo[i][0], nodeinfo[i][1], i+1, null, null);
}
// y๊ฐ์ด ํฐ ์์๋๋ก, y๊ฐ์ด ๊ฐ๋ค๋ฉด x๊ฐ์ด ์์ ์์๋๋ก ์ ๋ ฌํ๋ค.
Arrays.sort(node, new Comparator<Node>() {
@Override
public int compare(Node n1, Node n2) {
if (n1.y == n2.y) return n1.x - n2.x;
else return n2.y - n1.y;
}
});
// ํธ๋ฆฌ๋ฅผ ๋ง๋ ๋ค.
Node root = node[0];
for (int i=1; i<node.length; i++) {
insertNode(root, node[i]);
}
answer = new int[2][nodeinfo.length];
idx = 0;
preorder(root); // ์ ์ ์ํ
idx = 0;
postorder(root); // ํ์ ์ํ
return answer;
}
public void insertNode(Node parent, Node child) {
if (parent.x > child.x) {
if (parent.left == null) parent.left = child;
else insertNode(parent.left, child);
}
else {
if (parent.right == null) parent.right = child;
else insertNode(parent.right, child);
}
}
public void preorder(Node root) {
if (root != null) {
answer[0][idx++] = root.value;
preorder(root.left);
preorder(root.right);
}
}
public void postorder(Node root) {
if (root != null) {
postorder(root.left);
postorder(root.right);
answer[1][idx++] = root.value;
}
}
public class Node {
int x;
int y;
int value;
Node left;
Node right;
public Node(int x, int y, int value, Node left, Node right) {
this.x = x;
this.y = y;
this.value = value;
this.left = left;
this.right = right;
}
}
}
Reference
[ํ๋ก๊ทธ๋๋จธ์ค]๊ธธ ์ฐพ๊ธฐ ๊ฒ์ - JAVA
[ํ๋ก๊ทธ๋๋จธ์ค]๊ธธ ์ฐพ๊ธฐ ๊ฒ์ programmers.co.kr/learn/courses/30/lessons/42892 ์ฝ๋ฉํ ์คํธ ์ฐ์ต - ๊ธธ ์ฐพ๊ธฐ ๊ฒ์ [[5,3],[11,5],[13,3],[3,5],[6,1],[1,3],[8,6],[7,2],[2,2]] [[7,4,6,9,1,8,5,2,3],[9,6,5,8,1,4,3,2,7]] programmers.co.kr ํ์ด
moonsbeen.tistory.com
'Algorithms > programmers' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Programmers, ์ง์ง์ด ์ ๊ฑฐํ๊ธฐ : Java (0) | 2022.12.18 |
---|---|
Programmers, [3์ฐจ] ํ์ผ๋ช ์ ๋ ฌ : Java (2) | 2022.12.13 |
Programmers, [3์ฐจ] N์ง์ ๊ฒ์ : Java (3) | 2022.12.12 |
Programmers, ์คํจ์จ : Java (1) | 2022.12.10 |
Programmers, [3์ฐจ] ๋ฐฉ๊ธ๊ทธ๊ณก : Java (0) | 2022.12.08 |