- ๋ค์ต์คํธ๋ผ
- LCs
- ํธ๋ฆฌ
- nestjs
- ์น๋ฆฐ์ด
- go
- golang
- ์ฌ๋ผ์ด๋ฉ ์๋์ฐ
- ์นด์นด์ค2021
- ๋ฐฑ์ค
- ์์ฝ๋
- ์๊ณ ๋ฆฌ์ฆ
- ์ด๋ถํ์
- Union-Find
- ์นด์นด์ค ์ฝํ
- ์ฌ๊ท
- Python
- ๋นํธ๋งต
- ๊ฐ์ฅ๊ฐ๊น์ด๊ณตํต์กฐ์
- DFS
- C++
- ํ๋ก๊ทธ๋๋จธ์ค
- ๋นํธ๋ง์คํน
- ํ๋ฆฌ์จ๋ณด๋ฉ
- ๋ฐฑ์๋ ํ๋ฆฌ์จ๋ณด๋ฉ
- DP
- js
- ๋์ ํ๋ก๊ทธ๋๋ฐ
- ์ํฐ๋
- BFS
- Today
- Total
Hello Ocean! ๐ผ
[ํ๋ก๊ทธ๋๋จธ์ค/C++] ๊ธธ ์ฐพ๊ธฐ ๊ฒ์ ๋ณธ๋ฌธ

๋ฌธ์
๋ผ์ด์ธ์ด ๊ตฌ์ํ(๊ทธ๋ฆฌ๊ณ ์๋ง๋ ๋ผ์ด์ธ๋ง ์ฆ๊ฑฐ์ธ๋งํ) ๊ฒ์์, ์นด์นด์ค ํ๋ ์ฆ๋ฅผ ๋ ํ์ผ๋ก ๋๋๊ณ , ๊ฐ ํ์ด ๊ฐ์ ๊ณณ์ ๋ค๋ฅธ ์์๋ก ๋ฐฉ๋ฌธํ๋๋ก ํด์ ๋จผ์ ์ํ๋ฅผ ๋ง์น ํ์ด ์น๋ฆฌํ๋ ๊ฒ์ด๋ค.
๊ทธ๋ฅ ์ง๋๋ฅผ ์ฃผ๊ณ ๊ฒ์์ ์์ํ๋ฉด ์ฌ๋ฏธ๊ฐ ๋ํด์ง๋ฏ๋ก, ๋ผ์ด์ธ์ ๋ฐฉ๋ฌธํ ๊ณณ์ 2์ฐจ์ ์ขํ ๊ฐ์ ๊ตฌํ๊ณ ๊ฐ ์ฅ์๋ฅผ ์ด์งํธ๋ฆฌ์ ๋ ธ๋๊ฐ ๋๋๋ก ๊ตฌ์ฑํ ํ, ์ํ ๋ฐฉ๋ฒ์ ํํธ๋ก ์ฃผ์ด ๊ฐ ํ์ด ์ค์ค๋ก ๊ฒฝ๋ก๋ฅผ ์ฐพ๋๋ก ํ ๊ณํ์ด๋ค.
๋ผ์ด์ธ์ ์๋์ ๊ฐ์ ํน๋ณํ ๊ท์น์ผ๋ก ํธ๋ฆฌ ๋ ธ๋๋ค์ ๊ตฌ์ฑํ๋ค.
- ํธ๋ฆฌ๋ฅผ ๊ตฌ์ฑํ๋ ๋ชจ๋ ๋ ธ๋์ x, y ์ขํ ๊ฐ์ ์ ์์ด๋ค.
- ๋ชจ๋ ๋ ธ๋๋ ์๋ก ๋ค๋ฅธ x๊ฐ์ ๊ฐ์ง๋ค.
- ๊ฐ์ ๋ ๋ฒจ(level)์ ์๋ ๋ ธ๋๋ ๊ฐ์ y ์ขํ๋ฅผ ๊ฐ์ง๋ค.
- ์์ ๋ ธ๋์ y ๊ฐ์ ํญ์ ๋ถ๋ชจ ๋ ธ๋๋ณด๋ค ์๋ค.
- ์์์ ๋ ธ๋ V์ ์ผ์ชฝ ์๋ธ ํธ๋ฆฌ(left subtree)์ ์๋ ๋ชจ๋ ๋ ธ๋์ x๊ฐ์ V์ x๊ฐ๋ณด๋ค ์๋ค.
- ์์์ ๋ ธ๋ V์ ์ค๋ฅธ์ชฝ ์๋ธ ํธ๋ฆฌ(right subtree)์ ์๋ ๋ชจ๋ ๋ ธ๋์ x๊ฐ์ V์ x๊ฐ๋ณด๋ค ํฌ๋ค.
์๋ ์์๋ฅผ ํ์ธํด๋ณด์.
๋ผ์ด์ธ์ ๊ท์น์ ๋ง๊ฒ ์ด์งํธ๋ฆฌ์ ๋ ธ๋๋ง ์ขํ ํ๋ฉด์ ๊ทธ๋ฆฌ๋ฉด ๋ค์๊ณผ ๊ฐ๋ค. (์ด์งํธ๋ฆฌ์ ๊ฐ ๋ ธ๋์๋ 1๋ถํฐ N๊น์ง ์์๋๋ก ๋ฒํธ๊ฐ ๋ถ์ด์๋ค.)

์ด์ , ๋ ธ๋๋ฅผ ์๋ ๊ฐ์ (edge)์ ๋ชจ๋ ๊ทธ๋ฆฌ๋ฉด ์๋์ ๊ฐ์ ๋ชจ์์ด ๋๋ค.

์ ์ด์งํธ๋ฆฌ์์ ์ ์ ์ํ(preorder), ํ์ ์ํ(postorder)๋ฅผ ํ ๊ฒฐ๊ณผ๋ ๋ค์๊ณผ ๊ฐ๊ณ , ์ด๊ฒ์ ๊ฐ ํ์ด ๋ฐฉ๋ฌธํด์ผ ํ ์์๋ฅผ ์๋ฏธํ๋ค.
- ์ ์ ์ํ : 7, 4, 6, 9, 1, 8, 5, 2, 3
- ํ์ ์ํ : 9, 6, 5, 8, 1, 4, 3, 2, 7
๊ณค๊ฒฝ์ ๋น ์ง ์นด์นด์ค ํ๋ ์ฆ๋ฅผ ์ํด ์ด์งํธ๋ฆฌ๋ฅผ ๊ตฌ์ฑํ๋ ๋
ธ๋๋ค์ ์ขํ๊ฐ ๋ด๊ธด ๋ฐฐ์ด nodeinfo๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋,
๋
ธ๋๋ค๋ก ๊ตฌ์ฑ๋ ์ด์งํธ๋ฆฌ๋ฅผ ์ ์ ์ํ, ํ์ ์ํํ ๊ฒฐ๊ณผ๋ฅผ 2์ฐจ์ ๋ฐฐ์ด์ ์์๋๋ก ๋ด์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํ์.
์ ํ์ฌํญ
- nodeinfo๋ ์ด์งํธ๋ฆฌ๋ฅผ ๊ตฌ์ฑํ๋ ๊ฐ ๋
ธ๋์ ์ขํ๊ฐ 1๋ฒ ๋
ธ๋๋ถํฐ ์์๋๋ก ๋ค์ด์๋ 2์ฐจ์ ๋ฐฐ์ด์ด๋ค.
- nodeinfo์ ๊ธธ์ด๋ 1 ์ด์ 10,000 ์ดํ์ด๋ค.
- nodeinfo[i] ๋ i + 1๋ฒ ๋ ธ๋์ ์ขํ์ด๋ฉฐ, [x์ถ ์ขํ, y์ถ ์ขํ] ์์ผ๋ก ๋ค์ด์๋ค.
- ๋ชจ๋ ๋ ธ๋์ ์ขํ ๊ฐ์ 0 ์ด์ 100,000 ์ดํ์ธ ์ ์์ด๋ค.
- ํธ๋ฆฌ์ ๊น์ด๊ฐ 1,000 ์ดํ์ธ ๊ฒฝ์ฐ๋ง ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋ค.
- ๋ชจ๋ ๋ ธ๋์ ์ขํ๋ ๋ฌธ์ ์ ์ฃผ์ด์ง ๊ท์น์ ๋ฐ๋ฅด๋ฉฐ, ์๋ชป๋ ๋ ธ๋ ์์น๊ฐ ์ฃผ์ด์ง๋ ๊ฒฝ์ฐ๋ ์๋ค.
์ ์ถ๋ ฅ ์
nodeinfo | result |
[[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]] |
์ ์ถ๋ ฅ ์ ์ค๋ช
๋ฌธ์ ์ ์ฃผ์ด์ง ์์์ ๊ฐ๋ค.
๋ฌธ์ ๋ฅผ ์์ฝํด๋ณด๋ฉด,
"์ด์ง ํ์ํธ๋ฆฌ"๋ฅผ ๋ง๋ค์ด์, "์ ์ ์ํ"์ "ํ์ ์ํ"ํ ๊ฒฐ๊ณผ๋ฅผ returnํ๋ฉด ๋๋ ๊ฒ์ด๋ค.
์ฐจ์ด์ ์ด ์๋ค๋ฉด ํธ๋ฆฌ ๋ ธ๋์ ํํ์ด๋ค.
๋ณดํต์ ํธ๋ฆฌ ๋ ธ๋ | ์ด ๋ฌธ์ ์์์ ํธ๋ฆฌ ๋ ธ๋ | |
๊ตฌ์ฑ ์์ | key left ํฌ์ธํฐ right ํฌ์ธํฐ |
x y number(์ ๋ ฅ๋ ์์) left ํฌ์ธํฐ right ํฌ์ธํฐ |
์ฝ์ ๊ธฐ์ค | key | x |
์ํํ ๋ ํ์๋๋ ์ซ์ | key | number |
๋ณดํต์ ๊ฒฝ์ฐ์๋ key๊ฐ ํธ๋ฆฌ์ ๋ ธ๋๋ฅผ ์ฝ์ ํ ๋ ๊ธฐ์ค์ด ๋๋ ์ญํ ๊ณผ, ์ํ ์์ ๊ทธ ๋ ธ๋๋ฅผ ๋ํํ๋ ์ซ์๋ก ์ด์ฉ๋๋ค.
ํ์ง๋ง ์ด ๋ฌธ์ ์์๋ ์ฝ์ ๊ธฐ์ค์ x๊ฐ์ด ์ด์ฉ๋๊ณ , ์ํ ์์ ํด๋น ๋ ธ๋๋ฅผ ๋ํํ๋ ์ซ์๋ก๋ ์ ๋ ฅ๋ ์์(number)๊ฐ ์ด์ฉ๋๋ค.
ํ์ด
์ฒ์์๋ nodeinfo์ ๋ค์ด์๋ ์์๋๋ก ํธ๋ฆฌ๋ฅผ ๋ง๋ค์๋ค. ์ด ๊ฒฝ์ฐ, ๋ฌด์กฐ๊ฑด ์ฒซ ๋ฒ์งธ๋ก ์ ๋ ฅ๋ ๋ ธ๋๊ฐ root๊ฐ ๋์ด ๋ฌธ์ ์์ ์ ์๋ ๋ชจ์๋๋ก ํธ๋ฆฌ๋ฅผ ๋ง๋ค ์ ์์๋ค.

๋ฌธ์ ์ ์ฃผ์ด์ง ์ด ๊ทธ๋ฆผ์ ๋ณด๋ฉด, ํด๋น ๋ ธ๋์ y๊ฐ์ด ํด ์๋ก root์ชฝ์ผ๋ก ์์นํด ์๋ ๊ฒ์ ํ์ธํ ์ ์์๋ค. ๋จผ์ ์ฝ์ ๋ ์๋ก root์ ๊ฐ๊น๊ฒ ์์นํ๋ฏ๋ก, nodeinfo์ ๋ค์ด์๋ ๋ ธ๋๋ค์ y๊ฐ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ์ฌ ํธ๋ฆฌ์ ์ฝ์ ํ๋ค.
์ฝ๋
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
//x์ขํ : key ์ญํ
typedef struct Node{
public:
int x;
int y;
int number;
Node *left, *right;
}Node;
bool cmp(vector<int> a, vector<int> b) {
return a[1] > b[1];
}
void insert_node(Node **root, int x, int y, int number) {
Node *parent, *t;
Node *new_;
t = *root;
parent = NULL;
while (t != NULL) {
if (x == t->x)
return;
parent = t;
if (x < t->x)
t = t->left;
else
t = t->right;
}
new_ = (Node*)malloc(sizeof(Node));
if (new_ == NULL)
return;
new_->x = x;
new_->y = y;
new_->number = number;
new_->left = NULL;
new_->right = NULL;
if (parent != NULL)
if (x < parent->x)
parent->left = new_;
else
parent->right = new_;
else
*root = new_;
}
vector<int> pre_result;
void Preorder(Node *root) {
pre_result.push_back(root->number);
if (root->left)
Preorder(root->left);
if (root->right)
Preorder(root->right);
}
vector<int> post_result;
void Postorder(Node *root) {
if (root->left)
Postorder(root->left);
if (root->right)
Postorder(root->right);
post_result.push_back(root->number);
}
vector<vector<int>> solution(vector<vector<int>> nodeinfo) {
vector<vector<int>> answer;
int number = 0;
int x, y;
Node *root = NULL;
for (int i = 0;i < nodeinfo.size();i++) {
nodeinfo[i].push_back(i + 1);
}
sort(nodeinfo.begin(), nodeinfo.end(), &cmp);
for (int i = 0;i < nodeinfo.size();i++) {
x = nodeinfo[i][0];
y = nodeinfo[i][1];
number = nodeinfo[i][2];
insert_node(&root, x, y, number);
}
Preorder(root);
answer.push_back(pre_result);
Postorder(root);
answer.push_back(post_result);
return answer;
}
๊ฒฐ๊ณผ

์ฐธ๊ณ
ํธ๋ฆฌ์ ๋ ธ๋๋ฅผ ๊ตฌํํ๋ฉด์, c++์์ struct์ class์ ์ฐจ์ด์ ๋ํ์ฌ ์์๋ณด์๋ค.
bba-dda.tistory.com/entry/C-struct%EC%99%80-class%EC%9D%98-%EC%B0%A8%EC%9D%B4
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค/C++] ๋งค์นญ ์ ์ (0) | 2021.02.03 |
---|---|
[C++] struct์ class์ ์ฐจ์ด (0) | 2021.01.25 |
[C++/ํ๋ก๊ทธ๋๋จธ์ค] ๋ธ๋ก ์ด๋ํ๊ธฐ (0) | 2021.01.18 |
[ํ๋ก๊ทธ๋๋จธ์ค/C++] ํ๋ณดํค (0) | 2021.01.03 |
[ํ๋ก๊ทธ๋๋จธ์ค/C++] ํฌ๋ ์ธ ์ธํ๋ฝ๊ธฐ ๊ฒ์ (0) | 2020.12.29 |