๋์ด๋ : ๊ณจ๋ 2
๊ฑธ๋ฆฐ ์๊ฐ : 1์๊ฐ
๋ฌธ์
ํธ๋ฆฌ์ ๋์ด์ ๋๋น ๋ฌธ์ ๋ฐ๋ก๊ฐ๊ธฐ
์ด์งํธ๋ฆฌ๋ฅผ ๋ค์์ ๊ท์น์ ๋ฐ๋ผ ํ๊ณผ ์ด์ ๋ฒํธ๊ฐ ๋ถ์ด์๋ ๊ฒฉ์ ๋ชจ์์ ํ ์์ ๊ทธ๋ฆฌ๋ ค๊ณ ํ๋ค. ์ด๋ ๋ค์์ ๊ท์น์ ๋ฐ๋ผ ๊ทธ๋ฆฌ๋ ค๊ณ ํ๋ค.
- ์ด์งํธ๋ฆฌ์์ ๊ฐ์ ๋ ๋ฒจ(level)์ ์๋ ๋ ธ๋๋ ๊ฐ์ ํ์ ์์นํ๋ค.
- ํ ์ด์๋ ํ ๋ ธ๋๋ง ์กด์ฌํ๋ค.
- ์์์ ๋ ธ๋์ ์ผ์ชฝ ๋ถํธ๋ฆฌ(left subtree)์ ์๋ ๋ ธ๋๋ค์ ํด๋น ๋ ธ๋๋ณด๋ค ์ผ์ชฝ์ ์ด์ ์์นํ๊ณ , ์ค๋ฅธ์ชฝ ๋ถํธ๋ฆฌ(right subtree)์ ์๋ ๋ ธ๋๋ค์ ํด๋น ๋ ธ๋๋ณด๋ค ์ค๋ฅธ์ชฝ์ ์ด์ ์์นํ๋ค.
- ๋ ธ๋๊ฐ ๋ฐฐ์น๋ ๊ฐ์ฅ ์ผ์ชฝ ์ด๊ณผ ์ค๋ฅธ์ชฝ ์ด ์ฌ์ด์ ์๋ฌด ๋ ธ๋๋ ์์ด ๋น์ด์๋ ์ด์ ์๋ค.
์ด์ ๊ฐ์ ๊ท์น์ ๋ฐ๋ผ ์ด์งํธ๋ฆฌ๋ฅผ ๊ทธ๋ฆด ๋ ๊ฐ ๋ ๋ฒจ์ ๋๋น๋ ๊ทธ ๋ ๋ฒจ์ ํ ๋น๋ ๋ ธ๋ ์ค ๊ฐ์ฅ ์ค๋ฅธ์ชฝ์ ์์นํ ๋ ธ๋์ ์ด ๋ฒํธ์์ ๊ฐ์ฅ ์ผ์ชฝ์ ์์นํ ๋ ธ๋์ ์ด ๋ฒํธ๋ฅผ ๋บ ๊ฐ ๋ํ๊ธฐ 1๋ก ์ ์ํ๋ค. ํธ๋ฆฌ์ ๋ ๋ฒจ์ ๊ฐ์ฅ ์์ชฝ์ ์๋ ๋ฃจํธ ๋ ธ๋๊ฐ 1์ด๊ณ ์๋๋ก 1์ฉ ์ฆ๊ฐํ๋ค.
์ฐ๋ฆฌ๋ ์ฃผ์ด์ง ์ด์งํธ๋ฆฌ๋ฅผ ์์ ๊ท์น์ ๋ฐ๋ผ ๊ทธ๋ฆด ๋์ ๋๋น๊ฐ ๊ฐ์ฅ ๋์ ๋ ๋ฒจ๊ณผ ๊ทธ ๋ ๋ฒจ์ ๋๋น๋ฅผ ๊ณ์ฐํ๋ ค๊ณ ํ๋ค. ์์ ๊ทธ๋ฆผ์ ์์์ ๋๋น๊ฐ ๊ฐ์ฅ ๋์ ๋ ๋ฒจ์ 3๋ฒ์งธ์ 4๋ฒ์งธ๋ก ๊ทธ ๋๋น๋ 18์ด๋ค. ๋๋น๊ฐ ๊ฐ์ฅ ๋์ ๋ ๋ฒจ์ด ๋ ๊ฐ ์ด์ ์์ ๋๋ ๋ฒํธ๊ฐ ์์ ๋ ๋ฒจ์ ๋ต์ผ๋ก ํ๋ค. ๊ทธ๋ฌ๋ฏ๋ก ์ด ์์ ๋ํ ๋ต์ ๋ ๋ฒจ์ 3์ด๊ณ , ๋๋น๋ 18์ด๋ค.
์์์ ์ด์งํธ๋ฆฌ๊ฐ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ๋ ๋๋น๊ฐ ๊ฐ์ฅ ๋์ ๋ ๋ฒจ๊ณผ ๊ทธ ๋ ๋ฒจ์ ๋๋น๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค
ํ์ด
- ๊ฐ ๋ ธ๋์ ์ด์ ๊ตฌํ๋ ค๋ฉด ํธ๋ฆฌ๋ฅผ ์ค์์ํํ๋ฉด ๋๋ค.
์ฝ๋
#include <iostream>
#include <vector>
using namespace std;
struct Node {
int data;
Node* leftChild = nullptr;
Node* rightChild = nullptr;
Node* rootNode = nullptr;
Node(int d) {
int data = d;
}
};
Node* nodeArr[10001];
int nowPos = 1; // ํ์ฌ ์ด
int level = 0; // ํ์ฌ ๋ ๋ฒจ
int maxLevel = 0; // ์ต๋ ๋ ๋ฒจ ์ ์ฅ
int root = 0; // ๋ฃจํธ ๋
ธ๋ idx ์ ์ฅ
vector<vector<int>> width(10001, vector<int>()); // ๊ฐ ๋ ๋ฒจ์ ์ด ์ ์ฅ
void Inorder(Node* nodePtr) {
if (level > maxLevel)
maxLevel = level;
if (nodePtr->leftChild != nullptr) {
level++;
Inorder(nodePtr->leftChild);
level--;
}
width[level].push_back(nowPos++);
if (nodePtr->rightChild != nullptr) {
level++;
Inorder(nodePtr->rightChild);
level--;
}
}
Node* findRoot(Node* nodePtr) { // rootNode๋ฅผ ์ ์ฅํ์ฌ ์๋ก ํ๊ณ ์ฌ๋ผ๊ฐ๊ธฐ
while (nodePtr->rootNode != nullptr) {
nodePtr = nodePtr->rootNode;
}
return nodePtr;
}
int main() {
// 50๋ถ
// ์ค์ ์ํ!, ์ฐ๊ฒฐ๋ฆฌ์คํธ
int N; cin >> N;
Node* head;
for (int i = 1; i <= N; i++) { // ๋
ธ๋ ์ฝ์
Node* newNode = new Node(i);
newNode->data = i;
nodeArr[i] = newNode;
}
for (int i = 1; i <= N; i++) { // ์ฐ๊ฒฐ ๋ฆฌ์คํธ ๋ง๋ค๊ธฐ
int n, l, r; cin >> n >> l >> r;
Node* node = nodeArr[n];
if (l != -1) {
node->leftChild = nodeArr[l];
nodeArr[l]->rootNode = node;
}
if (r != -1) {
node->rightChild = nodeArr[r];
nodeArr[r]->rootNode = node;
}
}
Node* rootNode = findRoot(nodeArr[1]); // root๋ ์ฒซ๋ฒ์งธ๋ก ์ฃผ์ด์ง ๋
ธ๋๊ฐ ์๋ ์๋ ์์
Inorder(rootNode);
int maxResult = 0; int resultLv = 0;
for (int i = 1; i <= maxLevel; i++) {
int tmpWidth = width[i][width[i].size() - 1] - width[i][0];
if (tmpWidth > maxResult) {
maxResult = tmpWidth;
resultLv = i;
}
}
cout << resultLv+1 << " " << maxResult+1;
}
์ฃผ์ํ ์
- ํญ์ ์ด๊ธฐํ, ์ฒ์ ๊ฐ์ด ์ ๋ค์ด๊ฐ ์์ด์ผ ํ๋ค.
- ์ฌ๊ธฐ์์๋ ๋ ธ๋๊ฐ ๊ฐ ๋ ๋ฒจ์ ํ๋๋ฐ์ ์์ ๋ width๊ฐ 1์ด ๋จ์ ๋ง์กฑ ํด์ผํ๋ค.
- ์ฒซ๋ฒ์งธ๋ก ์ฃผ์ด์ง ๋ ธ๋๊ฐ root node๊ฐ ์๋ ์ ์๋ค.
๊ฒฐ๊ณผ
์์ด๋ | ๋ฉ๋ชจ๋ฆฌ | ์๊ฐ | ์ธ์ด | ์ฝ๋ ๊ธธ์ด |
---|---|---|---|---|
gmldms784 | 2868 | 12 | C++17 / ์์ | 1661 |
'Algorithm ๋ฌธ์ > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[c++] BOJ 1600 :: ๋ง์ด ๋๊ณ ํ ์์ญ์ด (0) | 2021.06.25 |
---|---|
[c++] BOJ 1194 :: ๋ฌ์ด ์ฐจ์ค๋ฅธ๋ค ๊ฐ์ (0) | 2021.06.02 |
[c++] BOJ 1525 :: ํผ์ฆ (0) | 2021.05.26 |
[c++] BOJ 9019 :: DSLR (0) | 2021.05.26 |
[c++] BOJ 2146 :: ๋ค๋ฆฌ ๋ง๋ค๊ธฐ (0) | 2021.05.18 |
Comment