27-seongwon030

[seongwon030]

🔗 문제 링크

최소비용구하기2

✔️ 소요된 시간

2시간

문제 설명

정점과 간선 사이의 비용이 주어지고 출발 지점에서 도착 지점에 주어질 때, 출발 지점에서 도착 지점까지의 최소 비용, 최소 비용을 갖는 경로에 포함되어있는 도시의 개수를 출력한다. 출발 도시와 도착 도시도 포함한다.

✨ 수도 코드

해당 문제는 다익스트라 알고리즘으로 최소비용을 갱신하면서 최소비용을 구해야 합니다.
출력과정에서 이전 노드를 기록하고 출력하는데 애를 좀 먹었습니다.

다익스트라

# 데이크 스트라 알고리즘
def di(start):
    q = []
    heapq.heappush(q, [0,start]) # 시작노드는 거리가 0 / 시작노드 번호
    distance[start] = 0 # 첫 노드 비용을 0으로 설정 

    while q:
      # dist 는 현재 노드까지 도달하는데 걸린 최소비용
      # node 는 현재 방문 중인 노드
        dist, node = heapq.heappop(q)

        if distance[node] < dist:  # 현재 꺼낸 거리가 기존 최단거리보다 크면 스킵
            continue
        for n,w in graph[node]: # 현재 노드의 인접 노드 탐색
            cost = dist + w # 가중치 더해서 새로운 거리를 계산

            if distance[n] > cost: # 기존 거리보다 짧으면 갱신
                distance[n]= cost  
                prev_node[n] = node  # 이전 노드를 기록
                heapq.heappush(q,[cost,n]) # 갱신된 인접 노드를 큐에 추가 

• 이전노드 기록은 prev_node 리스트에 저장해놓습니다.
• 다음 노드를 갱신하는 경우에만 기록합니다.

최단거리

di(v1)
print(distance[v2])

• 시작 지점인 v1 을 인자로 하여 다익스트라 함수를 실행 -> 출발노드에서 모든 노드까지의 최단거리를 계산
• 도착노드에 해당하는 v2까지의 거리를 구합니다

이전 도시들

path = [v2]
now = v2
while now != v1:
  now = prev_node[now]
  path.append(now)

path.reverse()
print(len(path))
print(' '.join(map(str,path)))

• prev_node 에는 v2(도착 노드)까지의 도시 번호가 저장되어 있습니다
• path : 도착노드를 초기값으로 하는 리스트
• 이전 노드에서 출발노드가 나올때까지 path에 도시 번호들을 저장합니다

[InSange]

그냥 단순하게 최소신장트리 + 값을 갱신해줄 때 이전 값을 기억해주면 되는 단순한 문제라고 생각했었습니다.

처음에 접근했을 때 양방향인 줄 알고 A <-> B 로 연결해서 풀었었습니다.
어찌저찌 값은 나오지만 길을 꼬았을 때 발생하는 예외 케이스가 명확히 존재했습니다.

그렇게 문제를 다시 읽어보았을 때 버스는 당연히 A -> B로 가는구나 고로 단방향이구나를 깨닫는데 시간을 좀 많이 소요했습니다 ^^;
저는 버스가 순환 버스도 되는줄 알고 A <-> B 였겠거니 했는데 아니더라구요 ㅎㅎ;
그래서 A <- B에 대한 코드를 제거했습니다. (문제가 조금 불친절 한 것 같기도하고..?)

이제 각 도시에서 최소 거리를 구했으니 이제 ans 배열에 지나온 도시들을 저장하면 되는데 이 부분은 따로 paths 배열을 만들어서 활용하였습니다.

다만 여기서 첫 번째로 저는 쉽게 가는 길이 떠오르지 않더군요. 그냥 DFS 방식으로 했습니다.

1. A번째 도시에서 B번째 도시로 가는 최소 비용을 M이라고 하였을 때
2. B번째 도시에서 A번째 도시로 가는 길들을 역방향으로 탐색해줍니다. 이때 역방향으로 가는 길들은 다익스트라를 통해 최소 비용을 구하면서 저장해줬습니다.
3. 여기서 계산이 조금 필요한게 M이라는 최소 비용이 있을 때 B번째 도시에서 B-1번째 도시로 이동하게 되면 M - COST[B-1]의 결과 값은 A 번째 도시에서 B-1 번째 도시로 가는데에 소요되는 최소 비용 값입니다.

고로 다음 도시로 이동하는데 드는 비용을 뺐을 때 A 번째 도시에서 N 번째 도시로 이동하는 비용의 값이 나오지 않으면 그 길은 최소 비용으로 구성된 도시가 아니라는 점을 이용하여 복잡도를 줄이고자 노력하였습니다.
아래가 해당 부분입니다.

bool FindPath(int cur, int cost)
{
	if (cur == start)
	{
		if(cost == 0) return true;
		return false;
	}

	for (auto node : paths[cur])
	{
		if (visited[node.index]) continue;
		if (distances[node.index] == cost - node.dist)
		{
			visited[node.index] = true;
			if (FindPath(node.index, cost - node.dist))
			{
				ans.push_back(node.index);
				return true;
			}
			visited[node.index] = false;
		}
	}

	return false;
}

당연히 시간 초과가 나길래 다시 생각을 해봤을 때 굳이 이럴필요는 없더군요. 그냥 값이 변했을 때, 즉 값이 변하는 것은 최소 비용 루트이기에 다음 노드에 현재 노드의 인덱스 값을 저장해주면 되었다는 것을 깨닫고 수정했지만 그래도 시간초과가 나더군요.

그래서 질문게시판을 조금 참고하게 되었더니 버스의 개수가 최대 10만개가 주어지는데 현재 방문한 노드를 기점으로 연결되어 있는 버스들의 개수를 계속 탐색하게 되면 시간 초과가 발생하는 것을 깨달았습니다.
고로 다음 지점을 방문할 때 뿐만 아니라 우선 순위 큐에 저장되어 있는 값들의 비용이 최소 비용으로 저장되어 있는 값보다 큰 경우는 체크해줄 필요가 없다는 것을 깨닫고 조건문을 추가해줬더니 통과하였습니다.

상당히 피곤했던 문제였습니다..

[InSange]

그냥 단순하게 최소신장트리 + 값을 갱신해줄 때 이전 값을 기억해주면 되는 단순한 문제라고 생각했었습니다.

처음에 접근했을 때 양방향인 줄 알고 A <-> B 로 연결해서 풀었었습니다. 어찌저찌 값은 나오지만 길을 꼬았을 때 발생하는 예외 케이스가 명확히 존재했습니다.

그렇게 문제를 다시 읽어보았을 때 버스는 당연히 A -> B로 가는구나 고로 단방향이구나를 깨닫는데 시간을 좀 많이 소요했습니다 ^^; 저는 버스가 순환 버스도 되는줄 알고 A <-> B 였겠거니 했는데 아니더라구요 ㅎㅎ; 그래서 A <- B에 대한 코드를 제거했습니다. (문제가 조금 불친절 한 것 같기도하고..?)

이제 각 도시에서 최소 거리를 구했으니 이제 ans 배열에 지나온 도시들을 저장하면 되는데 이 부분은 따로 paths 배열을 만들어서 활용하였습니다.

다만 여기서 첫 번째로 저는 쉽게 가는 길이 떠오르지 않더군요. 그냥 DFS 방식으로 했습니다.

1. A번째 도시에서 B번째 도시로 가는 최소 비용을 M이라고 하였을 때
2. B번째 도시에서 A번째 도시로 가는 길들을 역방향으로 탐색해줍니다. 이때 역방향으로 가는 길들은 다익스트라를 통해 최소 비용을 구하면서 저장해줬습니다.
3. 여기서 계산이 조금 필요한게 M이라는 최소 비용이 있을 때 B번째 도시에서 B-1번째 도시로 이동하게 되면 M - COST[B-1]의 결과 값은 A 번째 도시에서 B-1 번째 도시로 가는데에 소요되는 최소 비용 값입니다.

고로 다음 도시로 이동하는데 드는 비용을 뺐을 때 A 번째 도시에서 N 번째 도시로 이동하는 비용의 값이 나오지 않으면 그 길은 최소 비용으로 구성된 도시가 아니라는 점을 이용하여 복잡도를 줄이고자 노력하였습니다. 아래가 해당 부분입니다.

bool FindPath(int cur, int cost)
{
	if (cur == start)
	{
		if(cost == 0) return true;
		return false;
	}

	for (auto node : paths[cur])
	{
		if (visited[node.index]) continue;
		if (distances[node.index] == cost - node.dist)
		{
			visited[node.index] = true;
			if (FindPath(node.index, cost - node.dist))
			{
				ans.push_back(node.index);
				return true;
			}
			visited[node.index] = false;
		}
	}

	return false;
}

당연히 시간 초과가 나길래 다시 생각을 해봤을 때 굳이 이럴필요는 없더군요. 그냥 값이 변했을 때, 즉 값이 변하는 것은 최소 비용 루트이기에 다음 노드에 현재 노드의 인덱스 값을 저장해주면 되었다는 것을 깨닫고 수정했지만 그래도 시간초과가 나더군요.

그래서 질문게시판을 조금 참고하게 되었더니 버스의 개수가 최대 10만개가 주어지는데 현재 방문한 노드를 기점으로 연결되어 있는 버스들의 개수를 계속 탐색하게 되면 시간 초과가 발생하는 것을 깨달았습니다. 고로 다음 지점을 방문할 때 뿐만 아니라 우선 순위 큐에 저장되어 있는 값들의 비용이 최소 비용으로 저장되어 있는 값보다 큰 경우는 체크해줄 필요가 없다는 것을 깨닫고 조건문을 추가해줬더니 통과하였습니다.

상당히 피곤했던 문제였습니다..

전체 코드 입니다.

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

struct Node
{
	int index;
	int dist;

	Node(int index, int dist)
	{
		this->index = index;
		this->dist = dist;
	}
};

int n, m, start, goal;
vector<vector<Node>> nodes;
vector<int> paths;
vector<int> distances;
vector<bool> visited;

void Solve()
{
	cin >> n;

	nodes.assign(n + 1, vector<Node>());
	paths.assign(n + 1, 0);
	distances.assign(n + 1, 1e8);
	visited.assign(n + 1, false);

	cin >> m;

	while (m--)
	{
		int v1, v2, edge;

		cin >> v1 >> v2 >> edge;

		nodes[v1].push_back(Node(v2, edge));
	}
	
	cin >> start >> goal;

	priority_queue < pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;

	distances[start] = 0;
	pq.push({ 0, start });

	while (!pq.empty())
	{
		int cur_index = pq.top().second;
		int cur_dist = pq.top().first;
		pq.pop();

		if (cur_dist > distances[cur_index]) continue;
		for (auto node : nodes[cur_index])
		{
			int next_index = node.index;
			int next_dist = node.dist + cur_dist;

			if (next_dist < distances[next_index])
			{
				distances[next_index] = next_dist;
				pq.push({ next_dist, next_index });
				paths[next_index] = cur_index;
			}
		}
	}

	cout << distances[goal] << "\n";
	
	vector<int> ans;

	ans.push_back(goal);
	while (goal != start)
	{
		ans.push_back(paths[goal]);
		goal = paths[goal];
	}

	cout << ans.size() << "\n";

	auto printReverse = [&ans]() {
		for (auto it = ans.rbegin(); it != ans.rend(); ++it)
		{
			cout << *it << " ";
		}
		};

	printReverse();
}

int main()
{
	cin.tie(nullptr);
	ios::sync_with_stdio(false);

	Solve();

	return 0;
}