๊ฐ์ฅ ๋จผ ๋ ธ๋
https://programmers.co.kr/learn/courses/30/lessons/49189
์ฝ๋
#include <string>
#include <vector>
#include <set>
#include <queue>
#include <map>
using namespace std;
int solution(int n, vector<vector<int>> edge) {
int answer = 0;
map<int, vector<int>> linked_list;
set<int> list;
list.insert(1);
// ์ฐ๊ฒฐ ๋ฆฌ์คํธ ๋ง๋ค๊ธฐ
int size = edge.size();
for(int i=0; i<size; i++){
int first = edge[i][0];
int second = edge[i][1];
linked_list[first].push_back(second);
linked_list[second].push_back(first);
}
queue<int> q; q.push(1);
int q_size;
while(list.size()!=n){
q_size = q.size();
for(int i=0; i<q_size; i++){
int key = q.front(); q.pop();
vector<int> tmp = linked_list[key];
int size = tmp.size();
for(int i=0; i<size; i++){
auto ret = list.insert(tmp[i]);
if(ret.second!=false)
q.push(tmp[i]);
}
}
}
answer = q.size();
return answer;
}
์ค๋ช
์ฐ์ ๊ทธ๋ํ ๋ฌธ์ ๋๊น ๋ฐฐ์ด๋ก ํ์ง ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ก ํ์ง๋ฅผ ์๊ฐํ๋ค. ๋ฐฐ์ด๋ก ํ๊ฒ ๋๋ฉด ๋ฐฐ์ด์ ๊ณฑ์ ๊ตฌํด์ ์ฝ๊ฒ ํ ์ ์๊ฒ ์ง๋ง, ๋ฐฐ์ด์ ํํํ๋ ๊ฒ๋ถํฐ ๊ณต๊ฐ์ ๋ง์ด ์ฐจ์งํ๊ฒ ๋๊ณ ๋ฐฐ์ด์ ๊ณฑ ๊ณ์ฐ์ ์๊ฐ๋ณต์ก๋๊ฐ ํฐ ๊ณ์ฐ ์ค ํ๋์ด๋ค. ๋ ธ๋์ ๊ฐฏ์ n์ด 20,000์ดํ๋ผ๋ ์กฐ๊ฑด์์ ํ๋์ 2์ฐจ์ ๋ฐฐ์ด์ ํํํ๊ธฐ ์ํด 4x10^8์ ๊ณต๊ฐ์ด ํ์ํ ๊ฒ์ ์ ์ ์๊ณ , 2์ฐจ์ ๋ฐฐ์ด 2๊ฐ๋ฅผ ๊ณฑํ๋ ค๋ฉด 10^17 ์ ๋์ ์๊ฐ๋ณต์ก๋๊ฐ ์์๋๋ค. ๋ณดํต ์๊ฐ๋ณต์ก๋๋ฅผ 10^9 ์ดํ๋ก ์ก๋๋ฐ์ ๋ฐํ์ฌ ์ด๋ ๊ต์ฅํ ๋์ ์์ด๋ฏ๋ก ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ฅผ ์ด์ฉํ ํํ๋ฒ์ ์ฌ์ฉํ๊ธฐ๋ก ํ๋ค.
map<int, vector<int>> linked_list;
์ฐ๊ฒฐ๋ฆฌ์คํธ๋ฅผ ๊ตฌํํ๊ธฐ ์ํด์ ์ฒ์๋ถํฐ ๊ตฌ์กฐ์ฒด๋ฅผ ๋ง๋ค์ด์ ๊ตฌํํด๋ ๋์ง๋ง C++ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ธ STL์์ ์ง์ํ๋ map์ ์ฌ์ฉํ๊ธฐ๋ก ํ๋ค. key ๊ฐ์ผ๋ก ๋ ธ๋ ๋ฒํธ๋ฅผ ์ฃผ๊ณ , value ๊ฐ์ผ๋ก ํด๋น ๋ ธ๋์ ์ฐ๊ฒฐ๋ ๋ ธ๋์ ๋ฒํธ ๋ฐฐ์ด์ธ vector ๊ฐ์ ์ฃผ๋ฉด ์์ฝ๊ฒ ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ฅผ ๊ตฌํํ ์ ์๋ค.
set<int> list;
list.insert(1);
๊ทธ ํ, ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ฅผ ๋ฐ๋ผ์ 1๋ฒ ๋ ธ๋๋ถํฐ ์ฐ๊ฒฐ๋์ด์๋ ๋ ธ๋๋ค์ ์ฒดํฌํ๋ฉด์ ๋ชจ๋ ๋ ธ๋๊ฐ ์ฒดํฌ๋ ๋๊น์ง ์งํํด์ผํ๋ค. ์ด ๋, ๋ชจ๋ ๋ ธ๋์ ๋ค๋ ๋์ง ์ฒดํฌํ๊ธฐ ์ํด์๋ ๋นํธ๋ง์คํฌ๋ฅผ ์ฌ์ฉํ ์๋ ์๊ณ , vector์ ๊ฐ์ ๋ฐฐ์ด์ ํ์ํ ์๋ ์๋ค. ํ์ง๋ง ๋นํธ ๋ง์คํฌ๋ฅผ ์ฌ์ฉํ๊ธฐ์๋ n์ ๋ฒ์๊ฐ ๋๋ฌด ์ปค์ ๊ฐ๋น ๊ฐ๋ฅํ ์๋ฃํ์ด ์๊ณ , vector๋ฅผ ์ฌ์ฉํ๋ฉด ํด๋น ์์๊ฐ ์ด๋ฏธ ๋ค๋ ๋ ์์์ธ์ง๋ฅผ ์ฐพ๋ ๋ฐ์ ์๊ฐ์ด ์ค๋๊ฑธ๋ฆฐ๋ค. ๋ฐ๋ผ์ STL ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ set์ ์ด์ฉํ์ฌ ํ์ฌ๊น์ง ๋ค๋ฅธ ๋ ธ๋๋ฅผ ์ฒดํฌํ๋๋ก ํ์๋ค.
while(list.size()!=n){
q_size = q.size();
for(int i=0; i<q_size; i++){
// queue์ ์๋ ๋
ธ๋์ ์ฐ๊ฒฐ๋ ๋
ธ๋๋ฅผ ๋ชจ๋ ์ฒ๋ฆฌ
}
}
์ฝ๋ ๊ตฌํ ์ ์ฃผ์ํด์ผํ ์ ์ ๋ ธ๋๋ค์ BFS์ ๊ฐ์ ํํ๋ก ์ํํ๋ฉด ์๋๋ค๋ ๊ฒ์ด๋ค. BFS๋ ํ๋ฒ์ ์ํ์ ๊ธฐ์ค์ด ์์ด queue๊ฐ ๋น ๋๊น์ง ์งํํ๋ ๋ฐฉ๋ฒ์ผ๋ก, ์ด๋ ๊ฒ ๊ตฌํํ๊ฒ ๋๋ฉด n๊ฐ์ ๋ ธ๋๋ฅผ ๋ชจ๋ ์ํํ ์๊ฐ ์ด๋ค ๋ ธ๋๋ค์ด ๋ง์ง๋ง ์ํ์ ํฌํจ๋์ด์์๋ ์ง๋ฅผ ๊ตฌ๋ถํ๊ธฐ ์ด๋ ต๋ค. ๋ฐ๋ผ์ while ๋ด์ for๋ฌธ์ผ๋ก ๋จ๊ณ๋ฅผ ๋๋ ๋์๋ค.
์ผ์ชฝ BFS ๊ทธ๋ฆผ์์๋ 1๋ฒ ๋ ธ๋์ ์ฐ๊ฒฐ๋ 2, 3๋ฒ ๋ ธ๋๋ฅผ queue์ ๋ฃ์ ํ 2๋ฒ ๋ ธ๋์ ์ฐ๊ฒฐ๋ 5๋ฒ ๋ ธ๋๋ฅผ queue์ ๋ฃ๋ ๊ณผ์ ์ ์์ฐจ์ ์ผ๋ก ์คํํ๊ณ ์๋ค. ์ด๋ ๊ฒ ๊ตฌํํ๊ฒ ๋๋ฉด 3๋ฒ์ 1๋ฒ ๋ ธ๋๋ก๋ถํฐ ํ ๋ฒ์ ์ฐ๊ฒฐ๋ก ๋๋ฌํ ์ ์๊ณ 5๋ฒ์ 1๋ฒ ๋ ธ๋๋ก๋ถํฐ 2๋ฒ์ ์ฐ๊ฒฐ๋ก ๋๋ฌํ ์ ์์ง๋ง ์ด๋ฅผ ๊ตฌ๋ถํ ์ ์๊ฒ ๋๋ค.
๋ฐ๋ผ์ ์ค๋ฅธ์ชฝ ๊ทธ๋ฆผ์ฒ๋ผ 1๋ฒ ๋ ธ๋์ ์ฐ๊ฒฐ๋ 2, 3๋ฒ ๋ ธ๋๋ฅผ queue์ ๋ฃ์ ํ 2๋ฒ๊ณผ 3๋ฒ ๋ ธ๋์ ์ฐ๊ฒฐ๋ ๋ ธ๋๋ค์ queue์ ๋ชจ๋ ๋ฃ๊ณ ๋ค์ ๋จ๊ณ๋ก ๋์ด๊ฐ๊ฒ ํ๋ฉด ๊ฐ ๋จ๊ณ๋ง๋ค 1๋ฒ ๋ ธ๋์ ๋ช ๋ฒ์ ์ฐ๊ฒฐ๋ก ๋๋ฌํ ์ ์๋ ๋ ธ๋๋ค์ธ์ง๋ฅผ ๊ตฌ๋ถํ ์ ์๋ค.
[๋นํธ๋ง์คํฌ] : https://hini7.tistory.com/101
์ฑ์ ๊ฒฐ๊ณผ
๋ค๋ฅธ ์ฌ๋์ ํ์ด
์ธ์ ๋ฐฐ์ด๋ก ๊ทธ๋ํ๋ฅผ ํํํ๋ queue๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ์์ ๊ทธ๋๋ ์ฌ์ฉํ ํ์ด๊ฐ ๊ฝค ๋ง์๋ค. ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ฅผ ์ด์ฉํ ๋ฐฉ๋ฒ์ STL ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๋ importํด์ผํ๊ธฐ ๋๋ฌธ์, ์ด ๋ฐฉ๋ฒ๋ ์ข์ ๊ฒ ๊ฐ๋ค. (๊ณต๊ฐ๋ณต์ก๋๋ ์ฆ๊ฐํ๊ฒ ์ง๋ง)
'Algorithm ๋ฌธ์ > ํ๋ก๊ทธ๋๋จธ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[c++] ํ๋ก๊ทธ๋๋จธ์ค :: ๋น๋ฐ์ง๋ (๋ฌธ์ ํ์ด, ์ฝ๋) (0) | 2020.08.09 |
---|---|
[c++] ํ๋ก๊ทธ๋๋จธ์ค :: ๋ค์ ํฐ ์ซ์ (๋ฌธ์ ํ์ด, ์ฝ๋) (0) | 2020.08.07 |
[c++] ํ๋ก๊ทธ๋๋จธ์ค :: ๋ผ๋ฉด๊ณต์ฅ (๋ฌธ์ ํ์ด, ์ฝ๋) (0) | 2020.07.31 |
[c++] ํ๋ก๊ทธ๋๋จธ์ค :: ํ (๋ฌธ์ ํ์ด, ์ฝ๋) (0) | 2020.07.26 |
[c++] ํ๋ก๊ทธ๋๋จธ์ค :: ์นดํซ (brute force) (0) | 2020.05.28 |
Comment