https://www.acmicpc.net/problem/5567
5567๋ฒ: ๊ฒฐํผ์
์์ 1์ ๊ฒฝ์ฐ 2์ 3์ ์๊ทผ์ด์ ์น๊ตฌ์ด๋ค. ๋, 3๊ณผ 4๋ ์น๊ตฌ์ด๊ธฐ ๋๋ฌธ์, 4๋ ์๊ทผ์ด์ ์น๊ตฌ์ ์น๊ตฌ์ด๋ค. 5์ 6์ ์น๊ตฌ๋ ์๋๊ณ , ์น๊ตฌ์ ์น๊ตฌ๋ ์๋๋ค. ๋ฐ๋ผ์ 2, 3, 4 3๋ช ์ ์น๊ตฌ๋ฅผ ๊ฒฐํผ์์ ์ด๋
www.acmicpc.net
๋ฌธ์
์๊ทผ์ด๋ ์์ ์ ๊ฒฐํผ์์ ํ๊ต ๋๊ธฐ ์ค ์์ ์ ์น๊ตฌ์ ์น๊ตฌ์ ์น๊ตฌ๋ฅผ ์ด๋ํ๊ธฐ๋ก ํ๋ค. ์๊ทผ์ด์ ๋๊ธฐ๋ ๋ชจ๋ N๋ช ์ด๊ณ , ์ด ํ์๋ค์ ํ๋ฒ์ ๋ชจ๋ 1๋ถํฐ N๊น์ง์ด๋ค. ์๊ทผ์ด์ ํ๋ฒ์ 1์ด๋ค.
์๊ทผ์ด๋ ๋๊ธฐ๋ค์ ์น๊ตฌ ๊ด๊ณ๋ฅผ ๋ชจ๋ ์กฐ์ฌํ ๋ฆฌ์คํธ๋ฅผ ๊ฐ์ง๊ณ ์๋ค. ์ด ๋ฆฌ์คํธ๋ฅผ ๋ฐํ์ผ๋ก ๊ฒฐํผ์์ ์ด๋ํ ์ฌ๋์ ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ฒซ์งธ ์ค์ ์๊ทผ์ด์ ๋๊ธฐ์ ์ n (2 ≤ n ≤ 500)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค์๋ ๋ฆฌ์คํธ์ ๊ธธ์ด m (1 ≤ m ≤ 10000)์ด ์ฃผ์ด์ง๋ค. ๋ค์ ์ค๋ถํฐ m ๊ฐ ์ค์๋ ์น๊ตฌ ๊ด๊ณ ai bi๊ฐ ์ฃผ์ด์ง๋ค. (1 ≤ ai < bi ≤ n) ai์ bi๊ฐ ์น๊ตฌ๋ผ๋ ๋ป์ด๋ฉฐ, bi์ ai๋ ์น๊ตฌ๊ด๊ณ์ด๋ค.
์์ ์ ๋ ฅ ์์
๋ง์ฝ ์ด๋ ๊ฒ ์ ๋ ฅํ๋ค๋ฉด,
์๊ทผ์ด(1)๊ณผ 2๋ ์น๊ตฌ,
์๊ทผ์ด(1)๊ณผ 3์ ์น๊ตฌ,
3๊ณผ 4๋ ์น๊ตฌ,
2์ 3์ ์น๊ตฌ,
4์ 5๋ ์น๊ตฌ์ด๋ค.
โ
๋ฌธ์ ์์๋ ์๊ทผ์ด์ ์น๊ตฌ, ๊ทธ ์น๊ตฌ์ ์น๊ตฌ๊น์ง๊ฐ ๋ช ๋ช ์ธ์ง๋ฅผ ์ถ๋ ฅํ๋ ๊ฒ์ ์ํ๋ค.
๋ฐ๋ผ์ ์์๊ฐ ์์ ๊ฐ๋ค๋ฉด, ์๊ทผ์ด์ ์น๊ตฌ์ธ 2์ 3, ๊ทธ๋ฆฌ๊ณ 2์ 3, 3์ ์น๊ตฌ์ธ 4๊น์ง ํฌํจํ์ฌ 2,3,4๋ฒ ์ด 3๋ช ์ด๋ค.
๊ทธ๋ํ
์ด ๋ฌธ์ ๋ฅผ ๋ ์ฝ๊ฒ ํํํ๊ธฐ ์ํด์๋ ๊ทธ๋ํ๋ฅผ ์์์ผ ํ๋ค.
๊ทธ๋ํ๋, ์ด๋ค ์๋ฃ๋ ๊ฐ๋ ์ ํํํ๋ ์ ์ ๋ค์ ์งํฉ V์ ์ด๋ค์ ์ฐ๊ฒฐํ๋ ๊ฐ์ ๋ค์ ์งํฉ E๋ก ๊ตฌ์ฑ๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๋งํ๋ค.

๋นจ๊ฐ ์ ์ ๊ฐ์ edge ๋๋ link๋ผ๊ณ ํ๋ค. ์ด๋ก ์์ ์ ์ vertex ๋๋ node๋ผ๊ณ ํ๋ค.
์ด ๊ทธ๋ํ๋ก ํ์ค ์ธ๊ณ์ ์ฌ๋ฌผ์ด๋ ์ถ์์ ์ธ ๊ฐ๋ ๊ฐ์ ์ฐ๊ฒฐ ๊ด๊ณ๋ฅผ ํํํ ์ ์๋ค.
ํ์ค ์ธ๊ณ์ ์ฌ๋ฌผ์ ์ฐ๊ฒฐ ๊ด๊ณ์ ์๋ก๋ ์ด๋ฒ์ ํ์ดํ ๋ฐฑ์ค ๊ฒฐํผ์ ๋ฌธ์ ์ด๋ค.
์ถ์์ ์ธ ๊ฐ๋ ๊ฐ์ ์ฐ๊ฒฐ ๊ด๊ณ์ ์๋ก๋ ๋ง์ธ๋๋งต์ด ์๋ค.
โ
๊ทธ๋ํ ๊ธฐ๋ณธ ์ฉ์ด
- ์ธ์
์ ๊ทธ๋ฆผ์์ ์ ์ 1๊ณผ ์ ์ 2๋ ์ธ์ ํด์๋ค. ๋ ์ ์ 2์ 4๋ ์ธ์ ํด์๋ค.
'์ธ์ ํ๋ค'๋ผ๋ ์๋ฏธ๋ ์ ์ ๊ณผ ์ ์ ์ด ๊ฐ์ ์ผ๋ก ์ฐ๊ฒฐ๋์ด ์์ ๋๋ฅผ ๋งํ๋ค.
โ
-์ํ
์ ๊ทธ๋ฆผ์์ ์ ์ 1, ์ ์ 2, ์ ์ 3์ ์ํ์ด๋ค.
'์ํ'์ด๋ผ๋ ์๋ฏธ๋ ํ๋์ ์ ์ ์์ ์์ํ์ฌ ๋ช ๊ฐ์ ์ ์ ๋ค์ ๊ฑฐ์ณ ๋ค์ ์ฒ์์ ์ ์ ์ผ๋ก ๋์์ฌ ์ ์์ ๋๋ฅผ ๋งํ๋ค.
๊ทธ๋ํ์ ๊ตฌํ ๋ฐฉ๋ฒ
1. ์ธ์ ํ๋ ฌ

i, j
|
1
|
2
|
3
|
1
|
0
|
1
|
1
|
2
|
1
|
0
|
0
|
3
|
1
|
0
|
0
|
์ ํ๋ฅผ ํด์ํ๋ฉด,
1๊ณผ 1์ ์ธ์ ํ์ง ์์ 0, 1๊ณผ 2๋ ์ธ์ ํ์ฌ 1, 1๊ณผ 3์ ์ธ์ ํ์ฌ 1์ด๋ค.
2์ 1์ ์ธ์ ํ์ฌ 1, 2์ 2๋ ์ธ์ ํ์ง ์์ 0, 2์ 3์ ์ธ์ ํ์ง ์์ 0์ด๋ค.
3๊ณผ 1์ ์ธ์ ํ์ฌ 1, 3๊ณผ 2๋ ์ธ์ ํ์ง ์์ 0, 3๊ณผ 3์ ์ธ์ ํ์ง ์์ 0์ด๋ค.
โ
์ฝ๋๋ก ํํํ๋ค๋ฉด,
ํ๋ ฌ ์ด๋ฆ์ด a์ด๊ณ , ํ์ j, ์ด์ j์ด๋ค.
ํ i์ ์ด j๊ฐ ์ธ์ ํ๋ค๋ฉด, a[i][j] = 1์ด๊ณ ,
ํ i์ ์ด j๊ฐ ์ธ์ ํ์ง ์๋๋ค๋ฉด, a[i][j] = 0์ด๋ค.
โ
- ์ฅ์
์ธ์ ํ๋์ง, ์ธ์ ํ์ง ์์์ง ์ฝ๊ฒ ํ์ธ ๊ฐ๋ฅํ๋ค.
- ๋จ์
์ค์ ๋ก ์ธ์ ํ ์๊ณผ ์๊ด์์ด ๋ถํ์ํ ๊ณต๊ฐ์ ์ฐจ์งํ๋ค๋ ๋ฌธ์ ์ ์ด ์๋ค.
โ
2. ์ธ์ ๋ฆฌ์คํธ
โ
๋ฆฌ์คํธ๋ a, ์ ์ ์ ์๋ n์ด๋ค.
a[n]์์ a[i]๋ ์ ์ i๋ก๋ถํฐ ์์ํ๋ ๊ฐ์ ์ ์ฐ๊ฒฐ๋ ์ ์ ์ ์ฐ๊ฒฐํ๋ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ์์์ด๋ค.
โ
- ์ฅ์
์ค์ ๊ฐ์ ์๋งํผ์ ๊ณต๊ฐ์ ์ฌ์ฉํ์ฌ ๋ถํ์ํ ๊ณต๊ฐ์ ์ฐจ์งํ์ง ์๋๋ค.
- ๋จ์
์ธ์ ํ๋์ง, ์ธ์ ํ์ง ์์์ง ์ผ์ผ์ด ์ฐพ์์ผ ํ๋ค.
์ฝ๋ ์ค๋ช
1. call by reference
โ
void connect(int& a, int& b);
โ
ํจ์์ ํธ์ถ ๋ฐฉ์์๋ call by reference์ call by value๊ฐ ์๋ค.
call by value๋ ํจ์๊ฐ ํธ์ถ๋ ๋, ๋ฉ๋ชจ๋ฆฌ์ ๋ณ๋์ ์์ ๊ณต๊ฐ์ด ์์ฑ๋๋ค. ๋ฐ๋ผ์ ํจ์์์ ์ธ์์ ๊ฐ์ด ๋ณ๊ฒฝ๋์ด๋ ์๋ ๋ณ์์ ๊ฐ์ ๋ณ๊ฒฝ๋์ง ์๋๋ค.
call by reference๋ ํจ์๊ฐ ํธ์ถ๋ ๋, ๋ฉ๋ชจ๋ฆฌ์ ๋ณ๋์ ์์ ๊ณต๊ฐ์ด ์์ฑ๋์ง ์๊ณ ์๋ ์๋ ๋ฉ๋ชจ๋ฆฌ์ ๋ฎ์ด์ด๋ค. ๋ฐ๋ผ์ ํจ์์์ ์ธ์์ ๊ฐ์ด ๋ณ๊ฒฝ๋๋ฉด, ๋ค๋ฅธ ํจ์์์๋ ๊ทธ ์ธ์์ ๊ฐ์ด ๋ชจ๋ ๋ณ๊ฒฝ๋๋ค.
โ
2. ์ธ์ ํ๋ ฌ
โ
cin >> a >> b;
friends[a][b] = 1;
friends[b][a] = 1;
โ
์ ๋ ฅ๋ฐ์ a์ b๋ ์ฐ๊ฒฐ๋์ด ์๋ค๋ ์๋ฏธ์ด๋ฏ๋ก friends ํ๋ ฌ์ 1์ ๋ด๋๋ค.
๋ง์ฐฌ๊ฐ์ง๋ก ์ ๋ ฅ๋ฐ์ b์ a๋ ์ฐ๊ฒฐ๋์ด ์์ผ๋ฏ๋ก friends ํ๋ ฌ์ 1์ ๋ด๋๋ค.
โ
3.
โ
if (check[i] == 1)
connectedCount++;
โ
์ธ์ ํ๋ค๋ฉด connectedCount๋ฅผ 1์ ๋ํ๋ค.โ
โ
4.
โ
for (int a = 2; a <= n; a++)
โ
1์ ์๊ทผ์ด๋ฏ๋ก, 2๋ถํฐ n๊น์ง ๋ฐ๋ณตํ๋ค.
โ
5.
โ
if (friends[1][a])
{
check[a] = 1;
for (int b = 2; b <= n; b++)
{
if (friends[a][b] == 1) check[b] = 1;
}
}
โ
๋ง์ฝ 1(์๊ทผ์ด)์ a๊ฐ ์ฐ๊ฒฐ๋์ด ์์ผ๋ฉด, check ๋ฐฐ์ด์ a ๋ฒ ์งธ index์ 1์ ๋ด๋๋ค.
๊ทธ ํ, a์ ์ฐ๊ฒฐ๋ ์ ์ b๊ฐ ์๋ค๋ฉด check ๋ฐฐ์ด b ๋ฒ ์งธ index์ 1์ ๋ด๋๋ค.
โ
6.
โ
for (int i = 2; i <= n; i++)
{
if (check[i]) connectedCount++;
}
โ
check์ i ๋ฒ ์งธ index๊ฐ 1์ด๋ฉด 1์ true๋ผ๋ ์๋ฏธ๋ฅผ ๊ฐ์ง๊ณ ์์ผ๋ฏ๋ก, if ๋ฌธ์ ์คํํ๋ค.
connectedCount๋ 1๊ณผ ์ฐ๊ฒฐ๋์ด ์๋ ์ ์ ์ ์๋ฅผ ์๋ฏธํ๋ค.
์ฝ๋
#include<iostream>
using namespace std;
int n, m, a, b, connectedCount = 0;
int friends[501][501];
int check[501];
void connect(int& a, int& b);
int main()
{
cin >> n >> m;
for (int i = 0; i < m; i++)
{
cin >> a >> b;
friends[a][b] = 1;
friends[b][a] = 1;
}
connect(a, b);
for (int i = 2; i <= n; i++)
{
if (check[i]) connectedCount++;
}
cout << connectedCount << endl;
}
void connect(int& a, int& b)
{
for (int a = 2; a <= n; a++)
{
if (friends[1][a])
{
check[a] = 1;
for (int b = 2; b <= n; b++)
{
if (friends[a][b] == 1) check[b] = 1;
}
}
}
}

โ