"๋ฒจ๋ง ํฌ๋(bellman-ford) ์๊ณ ๋ฆฌ์ฆ "
์๊ณ ๋ฆฌ์ฆ ์ด๋ฆ์ด ๋ง์ ์๋ ๋ค. =3= ์๊ณ ๋ฆฌ์ฆ์ด๋ ์ํ์ ๋ฒ์น์ ๋ณด๋ฉด ๋ฐ๊ฒฌํ ์ฌ๋๋ค์ ์ด๋ฆ์ผ๋ก ์ด๋ฆ์ ๋ง๋ ๋ค. ์ง๊ด์ ์ด์ง ์์์ ๊ณ์ ๊น๋จน๊ฒ ๋๋ค. ์ง๊ด์ ์ผ๋ก ์ด๋ฆ์ ์ง์ด์คฌ์ผ๋ฉด ์ข๊ฒ ๋ค. ์๋ฅผ ๋ค์ด, "์์์ฌ์ดํด ๋ค์ต์คํธ๋ผ" ์ด๋ฐ์์ผ๋ก ~
1. ์ต๋จ ๊ฒฝ๋ก ํธ๋ฆฌ (shortest-path tree), ์ต์ ํด ๊ตฌ์กฐ(optimal substructure ์๊ณ ๋ฆฌ์ฆ์ด๋ค.
๋ต์ ์ฌ๋ฌ๊ฐ๊ฐ ์กด์ฌ ํ ์ ์์ผ๋ฉด ๊ฐ์ค์น๊ฐ ์๋ ๊ทธ๋ํ๋ก ์ต๋จ ๊ฒฝ๋ก๋ฅผ ์ฐพ๋๋ค.
2. ์์ ์ฌ์ดํด์ ์ ๋ฌด๋ฅผ ํ์ธํ ์ ์๋ค.
๋ค์ต์คํธ๋ผ๋ ๋ค๋ฅธ ์ !!์ผ๋ก ์์ ์ฌ์ดํด์ ๋ฐ์์ผ๋ก ์ต๋จ ๊ฒฝ๋ก๊ฐ ๋ฌดํ์ผ๋ก ๋น ์ง๋ ์์์ฐจ์ดํด์ ์ฐพ๋๋ค.
3. ๋ชจ๋ ์์ ๊ฐ์ ์ด ๋ฌธ์ ๋ค ?
์๋๋ค. (-) ๋ง์ด๋์ค ๊ฐ์ด ์๋๋ฐ ๋จ์ํ๊ฒ ๊ฒฝ๋ก ์์ ์์ด์ ๊ทธ ๊ฒฝ๋ก๋ฅผ ์์๋ก ๋ง๋ค์ง ์๋๋ค๋ฉด ๋ฌธ์ ๊ฐ ์๋ค.
์์์ ์์ ๋๋ฌ ๊ฐ๋ฅํ ์์ ์ํ์ด ๋ฌธ์ ๊ฐ ๋ ๋(B์ ๊ฐ์ ๊ฒฝ๋ก) ๋ฒจ๋งํฌ๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ํผํด์ค์ผํ๋ค.
4. ์ด๋ป๊ฒ ์ฐพ์๋ด๋๊ฐ ?
(์ ์ -1)๋ฒ์ ๋งค ์ ์ ์ ์ถ๊ฐํ๋ฉด ๋ชจ๋ ๊ฐ์ ์ ์ ๋ถ ํ์ธํ๋ฉด์ ๋ ธ๋๊ฐ์ ์ต๋จ๊ฑฐ๋ฆฌ๋ฅผ ๊ฐฑ์ ํ๋ค. ํ ๋ฒ ๋ชจ๋ ๋๊ณ ํ ๋ฒ ๋ ๋ฃจํ๋ฅผ ๋๋ ธ์๋ ๊ฐ์ ์ด ๋! ๋ ์์ ๊ฐ์ผ๋ก ๊ฐฑ์ ๋๋๊ฒ ์๋ค๋ฉด ์์ ์ฌ์ดํด์ด ์กด์ฌํ๋ค.
5. ๋ฌธ์ ๋ฅผ ํ๋ฉด์ ์์๋ณด์.
https://www.acmicpc.net/problem/1865
- N๊ฐ ์ง์
- M๊ฐ ๋๋ก ( ๋ฐฉํฅ x )
- W๊ฐ ์ํ ( ๋ฐฉํฅ o ) : ์ํ ๋ด์์๋ ์๊ณ๊ฐ ๊ฑฐ๊พธ๋ก ๊ฐ๋ค๊ณ ์๊ฐํ๋ฉด ๋๋ค.
1) ๋ชจ๋ ๋๊ณ ํ ๋ฒ ๋ ๋ฃจํ
2) Relax์ฐ์ฐ์ ์ฌ์ฉ.
๋ชจ๋ ๊ฐ์ ์ ๋ํด Relax๋ฅผ ์ํํ๋ค.
#include<iostream>
#include<vector>
#include<tuple>
#include<limits.h>
using namespace std;
vector<long>dist;
int main(void)
{
int Tc;
cin >> Tc;
while (Tc--)
{
int N, M, W;
cin >> N >> M >> W;
vector<tuple<int, int, int>> edges;
for (int i = 0 ; i < M; ++i) // ๋๋ก์ ์ ๋ณด
{
int S, E, T;
cin >> S >> E >> T;
edges.push_back(make_tuple(S, E, T));
edges.push_back(make_tuple(E, S, T));
}
for (int i = 0; i < W; ++i) // ์ํ์ ์ ๋ณด
{
int S, E, T;
cin >> S >> E >> T;
edges.push_back(make_tuple(S, E, -T));
}
dist.resize(N + 1);
fill(dist.begin(), dist.end(), INT_MAX);
bool cycle = false;
dist[1] = 0;
for (int i = 1; i <= N; ++i) // (n-1)๋ฒ ๋ฐ๋ณต.
{
for (int j = 0; j < edges.size(); ++j) // "๋ชจ๋ ๊ฐ์ " ํ๋์ฉ ํ์ธํ๋ค.
{
int from = get<0>(edges[j]);
int to = get<1>(edges[j]);
int cost = get<2>(edges[j]);
if (dist[to] > (dist[from] + cost))
{
if (i == N)
{
cycle = true;
break;
}
dist[to] = dist[from] + cost;
}
}
}
if (cycle)
{
cout << "YES\n";
}
else
{
cout << "NO\n" ;
}
}
return 0;
}
โป 14%์์ ๊ณ์ ํ๋ฆฌ๊ณ ์๋ค๋ฉด? "YES", "NO" ์๋ฌธ์ ๋๋ฌธ์ ํ์ธํ๊ธฐ!
'๐จ๐ปโ๐ป programming > โฝ ์๊ณ ๋ฆฌ์ฆ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ Algorithm/ KMP ์๊ณ ๋ฆฌ์ฆ ] (4) | 2024.07.23 |
---|---|
binary search & lower bound & upper bound [c++ ๊ตฌํ] (0) | 2024.07.05 |
[Algorithm/ ๋นํธ๋ง์คํฌ] (4) | 2023.02.17 |
[Algorithm/ Sparse Table (ํฌ์ํ ์ด๋ธ)] ๋ฐฑ์ค 17435๋ฒ๊ณผ ํจ๊ป (0) | 2023.02.01 |
[Algorithm/Shortest Path] A* ์๊ณ ๋ฆฌ์ฆ - ๊ตฌํC++ (0) | 2022.06.20 |
์ ํ๋ ๊ฒ ๋ณด๋ค ๋ซ๊ฒ ์ง
ํฌ์คํ ์ด ์ข์๋ค๋ฉด "์ข์์โค๏ธ" ๋๋ "๊ตฌ๋ ๐๐ป" ํด์ฃผ์ธ์!