[๋ฐฑ์ค] 1916๋ฒ - ์ต์๋น์ฉ ๊ตฌํ๊ธฐ (C++)
1916๋ฒ: ์ต์๋น์ฉ ๊ตฌํ๊ธฐ
์ฒซ์งธ ์ค์ ๋์์ ๊ฐ์ N(1 ≤ N ≤ 1,000)์ด ์ฃผ์ด์ง๊ณ ๋์งธ ์ค์๋ ๋ฒ์ค์ ๊ฐ์ M(1 ≤ M ≤ 100,000)์ด ์ฃผ์ด์ง๋ค. ๊ทธ๋ฆฌ๊ณ ์ ์งธ ์ค๋ถํฐ M+2์ค๊น์ง ๋ค์๊ณผ ๊ฐ์ ๋ฒ์ค์ ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋ค. ๋จผ์ ์ฒ์์๋ ๊ทธ
www.acmicpc.net
๋ฌธ์
N๊ฐ์ ๋์๊ฐ ์๋ค. ๊ทธ๋ฆฌ๊ณ ํ ๋์์์ ์ถ๋ฐํ์ฌ ๋ค๋ฅธ ๋์์ ๋์ฐฉํ๋ M๊ฐ์ ๋ฒ์ค๊ฐ ์๋ค. ์ฐ๋ฆฌ๋ A๋ฒ์งธ ๋์์์ B๋ฒ์งธ ๋์๊น์ง ๊ฐ๋๋ฐ ๋๋ ๋ฒ์ค ๋น์ฉ์ ์ต์ํ ์ํค๋ ค๊ณ ํ๋ค. A๋ฒ์งธ ๋์์์ B๋ฒ์งธ ๋์๊น์ง ๊ฐ๋๋ฐ ๋๋ ์ต์๋น์ฉ์ ์ถ๋ ฅํ์ฌ๋ผ. ๋์์ ๋ฒํธ๋ 1๋ถํฐ N๊น์ง์ด๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ๋์์ ๊ฐ์ N(1 ≤ N ≤ 1,000)์ด ์ฃผ์ด์ง๊ณ ๋์งธ ์ค์๋ ๋ฒ์ค์ ๊ฐ์ M(1 ≤ M ≤ 100,000)์ด ์ฃผ์ด์ง๋ค. ๊ทธ๋ฆฌ๊ณ ์ ์งธ ์ค๋ถํฐ M+2์ค๊น์ง ๋ค์๊ณผ ๊ฐ์ ๋ฒ์ค์ ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋ค. ๋จผ์ ์ฒ์์๋ ๊ทธ ๋ฒ์ค์ ์ถ๋ฐ ๋์์ ๋ฒํธ๊ฐ ์ฃผ์ด์ง๋ค. ๊ทธ๋ฆฌ๊ณ ๊ทธ ๋ค์์๋ ๋์ฐฉ์ง์ ๋์ ๋ฒํธ๊ฐ ์ฃผ์ด์ง๊ณ ๋ ๊ทธ ๋ฒ์ค ๋น์ฉ์ด ์ฃผ์ด์ง๋ค. ๋ฒ์ค ๋น์ฉ์ 0๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 100,000๋ณด๋ค ์์ ์ ์์ด๋ค.
๊ทธ๋ฆฌ๊ณ M+3์งธ ์ค์๋ ์ฐ๋ฆฌ๊ฐ ๊ตฌํ๊ณ ์ ํ๋ ๊ตฌ๊ฐ ์ถ๋ฐ์ ์ ๋์๋ฒํธ์ ๋์ฐฉ์ ์ ๋์๋ฒํธ๊ฐ ์ฃผ์ด์ง๋ค. ์ถ๋ฐ์ ์์ ๋์ฐฉ์ ์ ๊ฐ ์ ์๋ ๊ฒฝ์ฐ๋ง ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ์ถ๋ฐ ๋์์์ ๋์ฐฉ ๋์๊น์ง ๊ฐ๋๋ฐ ๋๋ ์ต์ ๋น์ฉ์ ์ถ๋ ฅํ๋ค.
ํ์ด๊ณผ์
์ถ๋ฐ ๋์์์ ๋์ฐฉ ๋์๊น์ง ๊ฐ๋๋ฐ ๋๋ ์ต์ ๋น์ฉ์ ๊ตฌํด์ผํ๋ ๋ฌธ์ .
๋ค์ต์คํธ๋ผ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ์ฌ ๋ฌธ์ ์ ์ ๊ทผํ์์ต๋๋ค.
์์ ๋์๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๋ชจ๋ ๋์๋ฅผ ๋๊ณ ๋ฐฉ์์ผ๋ก ์งํ์ด๋๊ณ ์๊ฐ๋ณต์ก๋๋ฅผ ์ค์ด๊ธฐ์ํด์ ๊ฐ์ฅ ์์ ๋น์ฉ์ ๊ฐ๋ถํฐ ๋ก์ง์ ๋๋๋ฐฉ์์ ๋๋ค.
๋ค์์ ๋์๊ฐ ๋์๋ค์ ๋น๊ตํด๊ฐ๋ฉด์ next๋์์ ์ ํ์๋ ๋น์ฉ๋ณด๋ค ์ง๊ธ ์ ๊ทผํ ์ ์๋ ๋น์ฉ์ด ์๋ค๋ฉด que์ push๋ฅผ ํ์ฌ ๋ก์ง์ ์ถ๊ฐ์ ์ผ๋ก ๋ ๋๋ ๋ฐฉ์
code
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
std::vector <std::pair<int, int> > vec[100001];
int dp[1001];
int INF = 100000001;
void dijkstra(int n, int sPos)
{
std::priority_queue <std::pair <int, int> > pQue;
dp[sPos] = 0;
pQue.push(std::make_pair(sPos, 0));
while (!pQue.empty())
{
int posCity = pQue.top().first;
int posCost = -pQue.top().second;
pQue.pop();
if (dp[posCity] < posCost) continue;
for (int i = 0; i < vec[posCity].size(); i++)
{
int nextCity = vec[posCity][i].first;
int nextCost = posCost + vec[posCity][i].second;
if (nextCost < dp[nextCity]) {
dp[nextCity] = nextCost;
pQue.push(std::make_pair(nextCity, -nextCost));
}
}
}
}
int main(void)
{
int n, m, stmp, etmp, sPos, ePos, cost;
std::cin >> n >> m;
for (int i = 0; i < m; i++) {
std::cin >> stmp >> etmp >> cost;
vec[stmp].push_back(std::make_pair(etmp, cost));
}
std::cin >> sPos >> ePos;
for (int i = 1; i <= n; i++) {
dp[i] = INF;
}
dijkstra(n, sPos);
std::cout << dp[ePos] << "\n";
return (0);
}
ํ๊ธฐ
์๋นํ ์ด๋ ต๋ค. ๋์ค์ ๋ค์ ๋์ ํด๋ด์ผํ ๋ฌธ์