๐ ๋ฌธ์ ๋ชฉ๋ก
- [๐ฅ4] 11404 - ํ๋ก์ด๋
- [๐ฅ5] 2660 - ํ์ฅ๋ฝ๊ธฐ
- [๐ฅ5] 15723 - n๋จ ๋ ผ๋ฒ
๊ฐ์ธ์ ์ผ๋ก ๊ณต๋ถํ ๋ด์ฉ์ ์์ฑํ ๊ฒ์ผ๋ก ํ๋ฆฐ ๋ถ๋ถ์ด ์์ ์ ์์ต๋๋ค
ํ๋ฆฐ ๋ถ๋ถ์ด ์๋ค๋ฉด ์ง์ ํด์ฃผ์๋ฉด ๊ฐ์ฌํ๊ฒ ์ต๋๋ค๐
1. ํ๋ก์ด๋
๋ฌธ์ ์ ๋ชฉ๋ถํฐ ์์ ํ๋ก์ด๋๋ผ๊ณ ์ ํ์๋๋งํผ ํ๋ก์ด๋ ์์
์๊ณ ๋ฆฌ์ฆ์ผ๋ก ํ ์ ์๋ ๋ํ์ ์ธ ์ ํ์ ๋ฌธ์ ์ด๋ค.
๋ชจ๋ ์ ์ ์ ์(A,B)์ ๋ํด A์์ B๋ก ๊ฐ๋ ์ต์๋น์ฉ์ ๋ชจ๋ ๊ตฌํ๋ ๋ฌธ์ .
์ฌ์ค ํ๋ก์ด๋ ์์
์๊ณ ๋ฆฌ์ฆ์ ์ด๋ฒ์ ์ฒ์ ์ ํ๋์ง ์๋๋ฉด ์ค๋๋์ด ๊น๋จน์ ๊ฑด์ง ๊ธฐ์ต์ด ์ ๋์;; ์ด ๋ฌธ์ ๋ ๊ณต๋ถํ๋ ๊ฒธ ์๊ณ ๋ฆฌ์ฆ ์ค๋ช
์ ๋ณด๋ฉด์ ๊ตฌํํ๋ค.
์ด ์๊ณ ๋ฆฌ์ฆ์ ์๊ฐ๋ณต์ก๋๋
1
2
๋ชจ๋ ์ ์ i์ ๋ํ์ฌ => O(V)
i๋ฅผ ๊ฑฐ์น๋ ๋ชจ๋ ๊ฒฝ๋ก(A->B)์ ๋ํด ๋น์ฉ์ ๋น๊ต => O(V^2)
์ด๋ฏ๋ก ์ด O(V^3)์ด ๋๋ค.
์ด ๋ฌธ์ ์์ ์ฝ๋๋ฅผ ์์ฑํ๋ฉด์ ๋ค์๊ณผ ๊ฐ์ ์ ์ ์ฃผ์ํ๋ค.
- ์ ๋ ฅ์์ ์ฃผ์ด์ง๋ ๊ฐ ์ค A->B๋ก ๊ฐ๋ ๋ ธ์ ์ด ์ฌ๋ฌ๊ฐ์ผ ์ ์์ผ๋ฏ๋ก ์ ๋ ฅ๋ฐ์ ๋๋ ์ต์๊ฐ์ผ๋ก ๊ฐฑ์ ํด์ฃผ์ด์ผ ํจ
- ๋ฌดํ(INF) ๊ฐ์ ์ถฉ๋ถํ ํฌ๊ฒ ํด ์ฃผ์ด์ผ ํจ:
๊ฐ ์ ์๋ ๊ฒฝ๋ก์ ๋ํ์ฌ INF ๊ฐ์ ์ ํด์ค ๋ ์ฒ์์๋ ๋จ์ํ ๋น์ฉ์ ์ต๋๊ฐ๋ณด๋ค 1 ํฐ 100,001๋ก ์ค์ ํด ์ฃผ์๋๋ฐ, ๋์์ ๊ฐ๋ ๊ฒฝ์ฐ๋ฅผ ๊ณ ๋ คํ๋ฉด ์ต์ํ (๋น์ฉ์ ์ต๋๊ฐ*(๋์์ ์ต๋ ๊ฐ์-1)+1) ์ด์์ผ๋ก ์ค์ ํด ์ฃผ์ด์ผ ํ๋ค. - ์ถ๋ฐ์ ๊ณผ ๋์ฐฉ์ ์ด ๊ฐ์ ๊ฒฝ์ฐ 0์ผ๋ก ์ด๊ธฐํ:
A->A ๊ฒฝ๋ก๊ฐ ์๋ค๊ณ ํ๋๋ผ๋ ์ด ๊ฒฝ์ฐ์๋ INF๋ก ์ด๊ธฐํํด์ฃผ๋ฉด ์๋๋ค. ์๋ ์ฝ๋๊ฐ์ ๊ฒฝ์ฐ์๋ ์ถ๋ฐ์ ๊ณผ ๋์ฐฉ์ ์ด ๊ฐ์ ๊ฒฝ์ฐ์ ๋ํด ๋ฐ๋ก ๋๊ฒจ์ฃผ์ง ์๊ธฐ ๋๋ฌธ์ i๋ฅผ ๊ฑฐ์น๋ ๊ฒฝ๋ก๋ก ๊ฐฑ์ ๋ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค.
๋ฌผ๋ก 2, 3๋ฒ์ ๊ฐ ์ ์๋ ๊ฒฝ๋ก
๋ ์ถ๋ฐ์ =๋์ฐฉ์
์ธ ๊ฒฝ์ฐ์ ๋ํด ํ๋ก์ด๋ ์์
์๊ณ ๋ฆฌ์ฆ์์ ํจ์คํ๋๋ก ์ฝ๋๋ฅผ ์์ฑํ๋ค๋ฉด ๊ตณ์ด ์ ๊ฒฝ์ฐ์ง ์์๋ ๋ ๋ถ๋ถ์ด๋ค.
๋๋ ์๋ ์ฝ๋์ ๊ฐ์ด 3์ค for๋ฌธ์ด ๊ฐ๊ฒฐํ ๋ฐฉ์์ผ๋ก ์์ฑํด์ ๊ทธ๋ ์ง๋ง, ๋ง์ฝ for๋ฌธ์์ ํจ์คํ๋๋ก ์กฐ๊ฑด๋ฌธ์ ๋ฃ์ด์ฃผ์๋ค๋ฉด
for๋ฌธ์ ๋๋ ์๊ฐ์ด ์ค์ด๋๋ฏ๋ก ์ฝ๊ฐ ์๋๋ฅผ ๋์ผ ์๋ ์์ ๊ฒ์ด๊ณ ,
๊ฐ ์ ์๋ ๊ฒฝ๋ก์ ์ถ๋ฐ์ =๋์ฐฉ์ ์ ๋ชจ๋ 0์ผ๋ก ์ด๊ธฐํํด๋์๋ค๋ฉด INF๋ ํ์ ์๊ณ ์ดํ 0์ผ๋ก ๊ณ ์ณ ์ถ๋ ฅํ ํ์๋ ์๋ค.
์ฝ๋
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include<iostream>
using namespace std;
const int MAX = 9900000;
int min(int a, int b) {
return (a < b) ? a : b;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
int cost[101][101];
cin >> n >> m;
fill_n(cost[0], 101 * 101, MAX + 1);
for (int i = 1; i <= n; i++) {
cost[i][i] = 0;
}
for (int i = 0; i < m; i++) {
int from;
int to;
int c;
cin >> from >> to >> c;
cost[from][to] = min(cost[from][to], c);
}
for (int i = 1; i <= n; i++) {
for (int from = 1; from <= n; from++) {
for (int to = 1; to <= n; to++) {
if (cost[from][to] > cost[from][i] + cost[i][to])
cost[from][to] = cost[from][i] + cost[i][to];
}
}
}
for (int from = 1; from <= n; from++) {
for (int to = 1; to <= n; to++) {
// ๊ฐ ์ ์์ ๊ฒฝ์ฐ 0์ผ๋ก ํ์
cout << ((cost[from][to] > MAX) ? 0 : cost[from][to]) << " ";
}
cout << "\n";
}
}
2. ํ์ฅ๋ฝ๊ธฐ
๋ฌธ์ ์ค๋ช
๋๋ฌธ์ ์ข ํท๊ฐ๋ฆด ์ ์์ง๋ง ์ด์ ๋ฌธ์ ์ ๊ฒฐ๊ตญ ๋๊ฐ๋ค.
(์์งํ ๋ชจ๋ฅด๊ณ ๋ดค์ผ๋ฉด ํ๋ก์ด๋ ์์
์๊ณ ๋ฆฌ์ฆ์ ๋ ์ฌ๋ฆฌ์ง ๋ชปํ์ ๊ฒ ๊ฐ๊ธฐ๋ ํ๋ค=_=;;)
์ฌ๊ธฐ์ ๋งํ๋ ํ์ฅํ๋ณด๋ ๋ค๋ฅธ ๋ชจ๋ ํ์๋ค๊ณผ ์ ์ผ ์ฌ์ด๊ฐ ๊ฐ๊น์ด ์ฌ๋, ์ฆ ๋ค๋ฅธ ๋ชจ๋ ์ ์ ๊ณผ ๊ฑฐ๋ฆฌ๊ฐ ๊ฐ์ฅ ๊ฐ๊น์ด ์ ์ ์ด๋ผ๋ ๋ป์ด๋ค.
์๋ฅผ ๋ค์ด ์ด๋ค ๋ชจ์์ ํ์ฅ ํ๋ณด์ ๊ฐ์ฅ ๋จผ ์น๊ตฌ์ฌ์ด๊ฐ โ์น๊ตฌ์ ์น๊ตฌโ ๋ผ๋ฉด ํ์ฅ ํ๋ณด์ ์ ์๋ 2์ด๋ค.
์ด์ ๋ฌธ์ ์ ๊ฐ์ด ๋ชจ๋ ํ์๋ค๊ณผ์ ์ต์ ๊ฑฐ๋ฆฌ๋ฅผ ์ ์ฅํ๊ธฐ ์ํด intํ 2์ฐจ์ ๋ฐฐ์ด์ ์ฌ์ฉํ๊ณ ,
๋ชจ๋ ํ์์ ๋ํ์ฌ ๊ฐ์ฅ ๋จผ ์ฌ์ด์ ๊ฐ์ ๊ตฌํด์ ์ค๋ฆ์ฐจ์ ์ ๋ ฌํด์ผ ํ๋ฏ๋ก ํ์์ ์ธ๋ฑ์ค
์ ๊ฐ์ฅ ๋จผ ์ฌ์ด ๊ฐ
์ ์ ์ฅํ๋ pairํ ๋ฐฐ์ด๋ ์ฌ์ฉํ๋ค.
(pairํ ๋ฐฐ์ด์ ์ ๋ ฌ์ ์ํด second ๊ฐ์ผ๋ก ๋น๊ตํ๋ compare ํจ์๋ฅผ ๋ง๋ค์ด ์ฃผ๊ณ sort()์์ ์ฌ์ฉํ์๋ค.)
๊ทธ๋ฆฌ๊ณ ์ดํ์ ํ์ฅ ํ๋ณด์ ์์ ํ๋ณด๋ฅผ ์ฐจ๋ก๋๋ก ์ถ๋ ฅํ๊ธฐ ์ํด intํ queue๋ ์ฌ์ฉํ๋ค.
์ฝ๋
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
bool compare(pair<int, int> a, pair<int, int> b) {
if (a.second == b.second) return a.first < b.first;
else return a.second < b.second;
}
int max(int a, int b) {
return (a > b) ? a : b;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
int score[51][51];
pair<int, int> max_score[51];
queue<int> candidate;
cin >> n;
fill_n(score[0], 51 * 51, n - 1);
for (int i = 1; i <= n; i++) {
score[i][i] = 0;
max_score[i] = { i,0 };
}
while (true) {
int a, b;
cin >> a >> b;
if (a == -1) break;
score[a][b] = 1;
score[b][a] = 1;
}
// from~to์ ์ต๋จ๊ฒฝ๋ก ๊ฐ๊ฐ ๊ตฌํ๊ธฐ
for (int i = 1; i <= n; i++) {
for (int from = 1; from <= n; from++) {
for (int to = 1; to <= n; to++) {
if (score[from][to] > score[from][i] + score[i][to])
score[from][to] = score[from][i] + score[i][to];
}
}
}
// ๊ฐ ์ ์ ์ ๋ํด ๋ค๋ฅธ ๋ชจ๋ ์ ์ ๊ณผ์ ๊ฑฐ๋ฆฌ ์ค ๊ฐ์ฅ ๋จผ ๊ฐ ๊ตฌํ๊ธฐ
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
max_score[i].second = max(max_score[i].second, score[i][j]);
}
}
// ์ ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ
sort(max_score + 1, max_score + n + 1, compare);
// ํ์ฅ ํ๋ณด๋ง ํ์ ๋ฃ์
candidate.push(max_score[1].first);
for (int i = 2; i <= n; i++) {
if (max_score[1].second == max_score[i].second) candidate.push(max_score[i].first);
else break;
}
cout << max_score[1].second << " " << candidate.size() << "\n";
while (!candidate.empty()) {
cout << candidate.front() << " ";
candidate.pop();
}
}
3. n๋จ ๋ ผ๋ฒ
AโB์ด๊ณ BโC์ด๋ฉด AโC์ด๋ค.
์์ ์ผ๋จ๋
ผ๋ฒ์ ์์ฉํด ์ ์ ์ ๊ฒฐ๋ก ์ด ์ฃผ์ด์ง๋ฉด ๊ฒฐ๋ก ์ด ์ฐธ์ธ์ง ๊ฑฐ์ง์ธ์ง๋ฅผ ํ๋ณํ๋ ๋ฌธ์ ์ด๋ค.
๊ฐ์ ๋น์ฉ์ด ๋ฐ๋ก ์์ผ๋ฏ๋ก ์ฌ๊ธฐ์๋ boolํ 2์ฐจ์ ๋ฐฐ์ด์ ์ฌ์ฉํด ์ผ์น ๊ด๊ณ(true/false)๋ง์ ์ ์ฅํ๋๋ก ํ๋ค.
์๊ณ ๋ฆฌ์ฆ์ ์ด์ ๋ฌธ์ ์ ๋ค๋ฅผ ๊ฒ ์๊ณ ๋จ์ํ์ง๋ง ๋ฐฐ์ด์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ธฐ ์ํด ์
๋ ฅ๋ฐ์ ๋ฌธ์๋ฅผ int๋ก ๋ณํํ๋ ์์
์ด ํ์ํ๋ค.
์ด๋ ๋๋ ์ ์ ๋ฌธ์ฅ์ getline()์ผ๋ก ํ๋ฒ์ ๋ฐ์์ ์ฒ์๊ณผ ๋์ ๋ฝ๋ ๋ฐฉ์์ผ๋ก ์์ฑํ๊ธฐ ๋๋ฌธ์ n, m์ ์
๋ ฅ๋ฐ์ ํ์ ๊ฐํ๋ฌธ์๋ฅผ ์ง์์ฃผ๊ธฐ ์ํด(flushing) cin.ignore()๋ฅผ ์ฌ์ฉํ๋๋ฐ
์คํฐ๋์๋ถ์๊ฒ ๋ฐ์ ํผ๋๋ฐฑ์ ์ํ๋ฉด ๊ทธ๋ฅ ๊ฐ๋จํ๊ฒ ์ค๊ฐ์ โisโ๋ฅผ string์ผ๋ก ๋ฐ์๋ฒ๋ ค๋ ๋๋ค.
์ฝ๋
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#include<iostream>
#include<string>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
bool equal[26][26];
char result[10];
cin >> n;
cin.ignore(32767, '\n');
fill_n(equal[0], 26 * 26, false);
// ์ ์ ์
๋ ฅ๋ฐ๊ธฐ
for (int i = 0; i < n; i++) {
string premise;
getline(cin, premise);
int first = premise.front() - 'a';
int second = premise.back() - 'a';
equal[first][second] = true;
equal[first][first] = true;
equal[second][second] = true;
}
// n๋จ ๋
ผ๋ฒ
for (int i = 0; i < 26; i++) {
for (int first = 0; first < 26; first++) {
for (int second = 0; second < 26; second++) {
if (equal[first][i] && equal[i][second]) {
equal[first][second] = true;
}
}
}
}
cin >> m;
cin.ignore(32767, '\n');
for (int i = 0; i < m; i++) {
string premise;
getline(cin, premise);
int first = premise.front() - 'a';
int second = premise.back() - 'a';
result[i] = (equal[first][second]) ? 'T' : 'F';
}
for (int i = 0; i < m; i++) {
cout << result[i] << "\n";
}
}