- BFS
- ์นด์นด์ค ์ฝํ
- DFS
- ๊ฐ์ฅ๊ฐ๊น์ด๊ณตํต์กฐ์
- ๋นํธ๋ง์คํน
- ํ๋ก๊ทธ๋๋จธ์ค
- ํธ๋ฆฌ
- ๋นํธ๋งต
- ๋์ ํ๋ก๊ทธ๋๋ฐ
- nestjs
- LCs
- ์๊ณ ๋ฆฌ์ฆ
- js
- ์์ฝ๋
- ์ฌ๋ผ์ด๋ฉ ์๋์ฐ
- ํ๋ฆฌ์จ๋ณด๋ฉ
- go
- ๋ฐฑ์๋ ํ๋ฆฌ์จ๋ณด๋ฉ
- DP
- ์นด์นด์ค2021
- ์ํฐ๋
- ์ด๋ถํ์
- ์ฌ๊ท
- ๋ค์ต์คํธ๋ผ
- Python
- Union-Find
- ๋ฐฑ์ค
- ์น๋ฆฐ์ด
- golang
- C++
- Today
- Total
Hello Ocean! ๐ผ
[๋ฐฑ์ค/C++] 2250. ํธ๋ฆฌ์ ๋์ด์ ๋๋น ๋ณธ๋ฌธ
๋ฌธ์
https://www.acmicpc.net/problem/2250
์ ๋ ฅ๋ ์ด์งํธ๋ฆฌ์ ๋ํด์ ๊ฐ ๋ ธ๋์ ๋ํด ์ธ๋ก์์น(์ด)๋ฒํธ๋ฅผ ๋งค๊ฒจ์ ๊ฐ์ฅ ๋์ ๋ ๋ฒจ์ ์ฐพ๊ณ , ๊ทธ ๋๋น๋ฅผ ์ถ๋ ฅํ๋ ๋ฌธ์ ์ด๋ค.
ํ์ด
left, rignt๊ฐ์ ๊ฐ์ง ๋ ธ๋๋ฅผ ๋ง๋ค๊ณ , ๋ ธ๋๋ฒํธ๊ฐ 0~N-1๊น์ง์ด๊ธฐ ๋๋ฌธ์ Nํฌ๊ธฐ์ ๋ ธ๋ ๋ฐฐ์ด์ ๋ง๋ค์ด ํธ๋ฆฌ๋ก ์ด์ฉํ๋ค.
-> ๋ฃจํธ๋ฅผ ์ ์ ์๊ธฐ ๋๋ฌธ์, ์ ๋ ฅ๋ฐ์ ๋ check๋ฐฐ์ด์ ์์ ,์ผ์ชฝ์์,์ค๋ฅธ์ชฝ์์ ๋ชจ๋ +1์ ํ๋ค.
์ ๋ ฅ์ ๋ค ๋ฐ์ ํ์ check[root] = 1์ด๊ณ , root๋ฅผ ์ ์ธํ ๋ชจ๋ ๋ ธ๋๋ 2์ด๋ค. ์ด๋ ๊ฒ ๋ฃจํธ๋ฅผ ์ฐพ์๋ค.
์ค์์ํ : ์ผ->์์ ->์ค ์์ผ๋ก ๋ฐฉ๋ฌธ
๋ฐ๋ผ์ ํธ๋ฆฌ๋ฅผ ์ค์์ํํ์ฌ 1๋ถํฐ ํ๋์ฉ ์ฆ๊ฐ์ํค๋ฉฐ ์ด๋ฒํธ๋ฅผ ๋งค๊ฒผ๋ค.
์ด ๋, level๊ฐ์ ์ด์ฉํ์ฌ min_col[level], max_col[level]์ ๊ฐ๊ฐ ํด๋น ๋ ๋ฒจ์ ์ต์ ์ด๋ฒํธ, ์ต๋ ์ด๋ฒํธ๋ฅผ ์ ์ฅํ๋ค.
* ์ด ํ์ํ๋ ๋ถ๋ถ์์ ์ฒ์์ BFS๋ DFS๊ฐ๋ ์ค์์๋ง ํ์ด๋ฅผ ์๊ฐํด์ ๊ต์ฅํ ๋ง๋งํ๋ค. ํธ๋ฆฌ์ ๊ฒฝ์ฐ ์ธ ๊ฐ์ง ์ํ๋ฐฉ์์ ๋จผ์ ๊ณ ๋ คํด๋ณด์..!
๋ง์ง๋ง์๋ min_col[level], max_col[level]๋ฅผ ๋๋ฉด์, max_col[level] - min_col[level] ์ ์ฐจ์ด๊ฐ ์ต์์ธ level์ ์ฐพ์๋ค.
์ฝ๋
#include <iostream>
using namespace std;
int N;
struct Node {
int left;
int right;
}Node;
// index 1~10000๊น์ง ์ด์ฉํ ๊ฒ
struct Node tree[10001];
int check[10001] = {0,}; // ๋ฃจํธ ์ฐพ๊ธฐ ์ํจ
int min_col[10001];
int max_col[10001];
int col=1;
void inorderTraverse(int num, int level){ //์ค์ ์ํ
// ์ผ์ชฝ ์๋ธํธ๋ฆฌ
if (tree[num].left > 0)
inorderTraverse(tree[num].left, level+1);
//์ค๊ฐ (์์ )
min_col[level] = min(min_col[level], col);
max_col[level] = max(max_col[level], col);
col++;
//์ค๋ฅธ์ชฝ ์๋ธํธ๋ฆฌ
if (tree[num].right > 0)
inorderTraverse(tree[num].right, level+1);
}
int main(void){
// input ์ฒ๋ฆฌ
cin >> N;
for (int i=0;i<N;i++){
int num, left, right;
cin >> num >> left >> right;
level[num]++;
if (left != -1)
level[left]++;
if (right != -1)
level[right]++;
tree[num].left = left;
tree[num].right = right;
}
//๋ฃจํธ ์ฐพ๊ธฐ
int root;
for (int i=1;i<=N;i++) {
if (check[i] == 1)
root = i;
}
fill(&min_col[0], &min_col[10001], 987654321); ///////
fill(&max_col[0], &max_col[10001], 0);
// ์ค์ ์ํ (์ด ๋ฒํธ ๋งค๊ธฐ๊ธฐ)
inorderTraverse(root, 1);
//์ต๋ ๋๋น์ ํด๋น ๋ ๋ฒจ ์ฐพ๊ธฐ
int result_level = 1;
int result_width = max_col[1] - min_col[1] + 1; //// +1
for (int i=2;i<=N;i++){
int width = max_col[i] - min_col[i] + 1;
if (result_width < width){
result_level = i;
result_width = width;
}
}
cout << result_level << " " << result_width<< endl;
return 0;
}
๊ฒฐ๊ณผ
์ฐธ๊ณ
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฐฑ์ค/C++] 1600. ๋ง์ด ๋๊ณ ํ ์์ญ์ด (0) | 2021.06.29 |
---|---|
[๋ฐฑ์ค/C++] 1194. ๋ฌ์ด ์ฐจ์ค๋ฅธ๋ค, ๊ฐ์ (0) | 2021.06.02 |
[๋ฐฑ์ค/C++] 9019. DSLR (0) | 2021.05.26 |
[๋ฐฑ์ค/C++] 1525. ํผ์ฆ (0) | 2021.05.26 |
[๋ฐฑ์ค/C++] 2146. ๋ค๋ฆฌ ๋ง๋ค๊ธฐ (0) | 2021.05.19 |