728x90
๊ทธ๋ํ์ DFS์ ๋๋์ด ํ๊ธด๋ค๋ฉด ์ด์ค ๋ฒกํฐ๋ฅผ ์ด์ฉํด์ Adjacent List๋ฅผ ๋ง๋ค๊ณ visited ๋ฒกํฐ๋ฅผ ์ด์ฉํด์ BFS๋ฅผ iterativeํ๊ฒ ๊ตฌ์ฑํ๋ค. ๊ทธ๋ฆฌ๊ณ BFS์ ๊ฒฝ์ฐ ์์ ๋ ธ๋์ ์ผ๋ง๋ ๋จ์ด์ ธ ์๋์ง๋ ์๋ก์ด ๋ฐฐ์ด์ ํ๋ ๋ง๋ค์ด์ค์ ์๊ณ ๋ฆฌ์ฆ์ ์์ฑํ๋ฉด ๋๋ค. while ๋ฌธ ์์ for ๋ฌธ์ ๊ฒฝ์ฐ ํ๋์ node๋ฅผ ์ค์ ํด๋๊ณ ๊ทธ ์ฃผ๋ณ ์ฐ๊ฒฐ๋ node๋ง์ ํ์ํ๋ ๊ฒ์ด๊ธฐ์ queue์์ front๋ก ์ฐธ์กฐํ node๋ ๋ณํ์ง ์๋๋ค๋ ์ฑ์ง์ ์ด์ฉํ์ฌ level์ ์ฒดํฌํด์ฃผ๋ฉด ๋๋ค.
#include <string>
#include <queue>
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
int solution(int n, vector<vector<int>> edge) {
int answer = 0;
vector<vector<int>> graph(n+1);
vector<bool> visited(n+1, false);
vector<int> counts(n+1,0);
queue<int> queue;
// Adjacent List๋ฅผ ๋ง๋ ๋ค. 2์ค ๋ฒกํฐ๋ฅผ ํ์ฉ
// ๋ฐฉํฅ์์ ์์ผ๋ฏ๋ก ์์ชฝ ๋๋ค ๋ฃ์ด์ค๋ค.
for(int i = 0 ; i < edge.size() ; i++) {
graph[edge[i][0]].push_back(edge[i][1]);
graph[edge[i][1]].push_back(edge[i][0]);
}
// 1์์ ๊ฐ์ฅ ๋จผ ๋
ธ๋๋ฅผ ํ์ํ๋ฏ๋ก 1์ ๋จผ์ ๋ฃ๋๋ค.
queue.push(1);
visited[1] = true;
// queue์ ์ด๋ค ๊ฒ์ด ๋ค์ด์๊ธฐ๋ง ํ๋ฉด ๊ณ์ ๋ฐ๋ณตํ๋ค.
while(!queue.empty()) {
// queue์ front์ ์์๋ฅผ ๋ฐ์์จ๋ค.
int node = queue.front();
queue.pop();
// front ์์์ ์ฃผ๋ณ node๋ฅผ ํ์ํ๊ธฐ ์ํด ๋ฐ๋ณต๋ฌธ์ ๊ตฌ์ฑ
for(int i = 0 ; i < graph[node].size() ; i++) {
// ๋ง์ฝ front๋ถํฐ ์์ํ๋ ๊ทธ๋ํ์ ์ฐ๊ฒฐ๋ ๋
ธ๋๊ฐ ๋ฐฉ๋ฌธ๋์ง ์์ ๊ฒฝ์ฐ
if(!visited[graph[node][i]]) {
// currentCount ๋ณ์๋ฅผ ๋ง๋ค์ด +1 ์ ํด์ค๋ค.
// 1์์ ์ผ๋ง๋ ๋จ์ด์ ธ์๋์ง๋ฅผ indexํ ์์ผ ๋น๊ตํ๋ค.
int currentCount = counts[node] + 1;
visited[graph[node][i]] = true;
// ๋ฐฉ๋ฌธํ node์ ํด๋นํ๋ index์ level์ ๋ถ์ฌํ๋ค.
counts[graph[node][i]] = currentCount;
// ํด๋น node๋ฅผ queue์ push ํด์ค๋ค.
queue.push(graph[node][i]);
}
}
}
// counts ๋ฐฐ์ด์ begin๋ถํฐ end๊น์ง ๋ด๋ฆผ์ฐจ์์ผ๋ก sort ์ํจ๋ค.
sort(counts.begin(), counts.end(), greater<int>());
// ๋ง์ฝ count์ ๊ฐ์ฅ ํฐ ์์์ ๊ฐ์ง ์๋ ๊ฒฝ์ฐ๊ฐ ๋์จ๋ค๋ฉด level์ด ๋ฎ์์ง ๊ฒ์ด๋ฏ๋ก
// ํด๋น ์กฐ๊ฑด์ ๊ฒฝ์ฐ break ํ๊ณ ๊ทธ๋ ์ง ์์ผ๋ฉด answer๋ฅผ ํ๋์ฉ ์ฆ๊ฐ์ํจ๋ค.
for(auto cnt : counts) {
if(cnt != counts[0]) break;
answer++;
}
return answer;
}