길찾기 Archives - 어제와 내일의 나 그 사이의 이야기

백준 1613번 (역사, C++, Floyd-Warshall) [BAEKJOON]

lycos7560 — Sat, 18 Feb 2023 01:44:41 +0000

목차 테이블

역사
접근 방법
통과된 코드

역사

https://www.acmicpc.net/problem/1613

시간 제한	메모리 제한	제출	정답	맞힌 사람	정답 비율
1 초	128 MB	13395	4248	3117	34.196%

문제

역사, 그 중에서도 한국사에 해박한 세준이는 많은 역사적 사건들의 전후 관계를 잘 알고 있다.

즉, 임진왜란이 병자호란보다 먼저 일어났으며, 무오사화가 기묘사화보다 먼저 일어났다는 등의 지식을 알고 있는 것이다.

세준이가 알고 있는 일부 사건들의 전후 관계들이 주어질 때, 주어진 사건들의 전후 관계도 알 수 있을까?

이를 해결하는 프로그램을 작성해 보도록 하자.

입력

첫째 줄에 첫 줄에 사건의 개수 n(400 이하의 자연수)과 알고 있는 사건의 전후 관계의 개수 k(50,000 이하의 자연수)가 주어진다.

다음 k줄에는 전후 관계를 알고 있는 두 사건의 번호가 주어진다.

이는 앞에 있는 번호의 사건이 뒤에 있는 번호의 사건보다 먼저 일어났음을 의미한다.

물론 사건의 전후 관계가 모순인 경우는 없다.

다음에는 사건의 전후 관계를 알고 싶은 사건 쌍의 수 s(50,000 이하의 자연수)이 주어진다.

다음 s줄에는 각각 서로 다른 두 사건의 번호가 주어진다.

사건의 번호는 1보다 크거나 같고, N보다 작거나 같은 자연수이다.

출력

s줄에 걸쳐 물음에 답한다.

각 줄에 만일 앞에 있는 번호의 사건이 먼저 일어났으면 -1,

뒤에 있는 번호의 사건이 먼저 일어났으면 1, 어떤지 모르면(유추할 수 없으면) 0을 출력한다.

예제 입력 1

예제 출력 1

0
-1
1

출처

문제를 만든 사람: author5
데이터를 추가한 사람: djs100201
문제의 오타를 찾은 사람: joonas

알고리즘 분류

접근 방법

통과된 코드

#include 
#include 
#include 

using namespace std;

int n, k, f, b, s;

constexpr int MAX = 401;

vector> graph[MAX];

list> myList;

int disArr[MAX][MAX];

int main()
{
	ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
	// cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
	cin.tie(NULL);
	cout.tie(NULL);

	cin >> n >> k;

	// 사건의 전후 관계 입력
	for (int i = 0; i < k; i++) {
		cin >> f >> b;
		graph[f].push_back(make_pair(b, -1));
		graph[b].push_back(make_pair(f, 1)); // 역방향 가능
	}

	// 질문을 입력 받는다.
	cin >> s;

	pair tempP;

	while (s--) { // 문제를 입력받는다.
		cin >> tempP.first >> tempP.second;
		myList.push_back(tempP);
	}

	for (int i = 1; i <= n; i++) {
		for (int j = 0; j < graph[i].size(); j++) {
			int v = graph[i][j].first;
			int weight = graph[i][j].second;
			disArr[i][v] = weight;
		}
	}


	for (int k = 1; k <= n; k++) {
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= n; j++) {
				if (i == j) disArr[i][j] = 0;
				else if (disArr[i][k] == 1 && disArr[k][j] == 1) disArr[i][j] = 1;
				else if (disArr[i][k] == -1 && disArr[k][j] == -1) disArr[i][j] = -1;
			}
		}
	}

	for (auto it = myList.begin(); it != myList.end(); it++) {
		cout << disArr[it->first][it->second] << "\n";

	}

	return 0;
}

The post 백준 1613번 (역사, C++, Floyd-Warshall) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

백준 1507번 (궁금한 민호, C++, Floyd-Warshall) [BAEKJOON]

lycos7560 — Fri, 17 Feb 2023 07:43:51 +0000

목차 테이블

궁금한 민호
접근 방법
통과된 코드

궁금한 민호

https://www.acmicpc.net/problem/1507

시간 제한	메모리 제한	제출	정답	맞힌 사람	정답 비율
2 초	128 MB	5291	2771	2180	51.198%

문제

강호는 N개의 도시로 이루어진 나라에 살고 있다.

각 도시는 M개의 도로로 연결되어 있으며, 각 도로를 지날 때 필요한 시간이 존재한다.

도로는 잘 연결되어 있기 때문에, 도시 A에서 B로 이동할 수 없는 경우는 존재하지 않는다.

도시 A에서 도시 B로 바로 갈 수 있는 도로가 있거나,

다른 도시를 거쳐서 갈 수 있을 때, 도시 A에서 B를 갈 수 있다고 한다.

강호는 모든 쌍의 도시에 대해서 최소 이동 시간을 구해놓았다.

민호는 이 표를 보고 원래 도로가 몇 개 있는지를 구해보려고 한다.

예를 들어, 예제의 경우에 모든 도시 사이에 강호가 구한 값을 가지는 도로가 존재한다고 해도 된다.

하지만, 이 도로의 개수는 최솟값이 아니다.

예를 들어, 도시 1-2, 2-3, 1-4, 3-4, 4-5, 3-5를 연결하는 도로만 있다고 가정해도, 강호가 구한 모든 쌍의 최솟값을 구할 수 있다.

이 경우 도로의 개수는 6개이고, 모든 도로의 시간의 합은 55이다.

모든 쌍의 도시 사이의 최소 이동 시간이 주어졌을 때,

이 나라에 존재할 수 있는 도로의 개수의 최솟값일 때, 모든 도로의 시간의 합을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 도시의 개수 N(1 ≤ N ≤ 20)이 주어진다.

둘째 줄부터 N개의 줄에 각각의 도시 사이에 이동하는데 필요한 시간이 주어진다.

A에서 B로 가는 시간과 B에서 A로 가는 시간은 같다. 또, A와 B가 같은 경우에는 0이 주어지고,

그 외의 경우에 필요한 시간은 2500보다 작거나 같은 자연수이다.

출력

첫째 줄에 도로 개수가 최소일 때, 모든 도로의 시간의 합을 출력한다.

불가능한 경우에는 -1을 출력한다.

예제 입력 1

5
0 6 15 2 6
6 0 9 8 12
15 9 0 16 18
2 8 16 0 4
6 12 18 4 0

예제 출력 1

예제 입력 2

예제 출력 2

예제 입력 3

8
0 1 6 17 26 13 7 16
1 0 5 16 25 12 7 15
6 5 0 21 21 8 12 11
17 16 21 0 41 28 23 31
26 25 21 41 0 13 32 10
13 12 8 28 13 0 19 3
7 7 12 23 32 19 0 22
16 15 11 31 10 3 22 0

예제 출력 3

예제 입력 4

예제 출력 4

-1

출처

문제를 번역한 사람: baekjoon
빠진 조건을 찾은 사람: medic_programmer

알고리즘 분류

접근 방법

i -> j로 가는 최단경로와 i -> k, k -> j 로 가는 최단경로의 합이 같다면 i -> j경로는 없애준다.

i -> j의 최단경로가 더 크다면 입력이 잘못된 것이므로 result를 -1로 저장해준다.

통과된 코드

#include 

using namespace std;

constexpr int MAX = 21;

int disArr[MAX][MAX];

int route[MAX][MAX];

int N, result;

int main()
{
	ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
	// cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
	cin.tie(NULL);
	cout.tie(NULL);

	cin >> N;

	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= N; j++) {
			cin >> disArr[i][j];
			route[i][j] = disArr[i][j];
		}
	}

	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= N; j++) {
			for (int k = 1; k <= N; k++) {

				if (j == k || i == k) continue;

				// 불가능한 경우이므로 -1 출력
				if (disArr[i][j] > disArr[i][k] + disArr[k][j]) {
					cout << "-1";
					return 0;
				}

				// 경로를 지워준다.
				if (disArr[i][j] == disArr[i][k] + disArr[k][j]) route[i][j] = 0;
			}
		}
	}


	for (int i = 1; i <= N; i++) 
		for (int j = 1; j <= N; j++) result += route[i][j];
	
	// 반으로 나누어준다.
	cout << result / 2;

	return 0;
}

The post 백준 1507번 (궁금한 민호, C++, Floyd-Warshall) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

백준 11562번 (백양로 브레이크, C++, Floyd-Warshall) [BAEKJOON]

lycos7560 — Fri, 17 Feb 2023 04:38:02 +0000

목차 테이블

백양로 브레이크
접근 방법
시간 초과 코드 (DFS)
통과된 코드

백양로 브레이크

https://www.acmicpc.net/problem/11562

시간 제한	메모리 제한	제출	정답	맞힌 사람	정답 비율
1 초	256 MB	2698	1354	1024	47.828%

문제

서울 소재 Y모 대학교에서 대규모 공사를 진행하면서, 학교가 마치 미로처럼 변해버리고 말았다.

공사 이전까지는 어떤 건물에서 출발하더라도 다른 모든 건물로 갈 수 있는 길이 있었으나,

공사가 진행되면서 어떻게 한 건진 알 수 없지만 일방통행만 가능한 길이 많이 늘고 말았다.

컴퓨터과학과 학생 남규는 전공 수업을 듣고 교양 수업을 들으러 가던 중

길을 잃어 3일 밤낮을 헤매다가 공학관에서 종합관으로 가는 길은 존재하지 않는다는 결론을 내렸다.

3일 사이에 과제도 내지 못하고 출석도 하지 못해 학사경고 위기에 처한 남규는 전공을 살려

현재 일방통행인 길들 중 반드시 양방향으로 바꿔야만 하는 길이 몇 개인지 조사해 학교에 건의하기로 마음을 먹었다.

남규는 여러 건물들 사이를 직접 잇는 길들을 모두 조사했고,

그 중 어떤 길들이 일방통행인지, 또는 양방향 통행이 가능한지를 모두 체크했다.

남규의 프로그램은 간단하다.

출발지와 도착지를 입력하면 도착지까지 가기 위해 최소 몇 개의 길을 양방향으로 바꿔야만 하는지를 출력해준다.

프로그램이 완성되었다는 소문이 퍼지자, 남규처럼 길을 잃고 헤맨 경험이 있는 학생들은 남규에게 묻기 시작했다.

“공학관에서 대강당 갈 수 있어?”

“상경대 별관에서 학관으로는?”

남규는 매번 손으로 타이핑해 입력하고 결과를 보내주는 데에 지치고 말았다.

결국 앓아누운 남규를 위해 학생들의 질문을 해결할 새로운 프로그램을 만들어보자.

입력

첫 줄에 Y대학교 건물의 수 n과 길의 수 m이 주어진다. (n ≤ 250, m ≤ n * (n – 1) / 2 )

다음 m줄에 걸쳐, u v b (1 ≤ u ≤ n, 1 ≤ v ≤ n, u != v, b = 0 또는 1) 의 형태로 길에 대한 정보가 주어진다.

b가 0일 경우 u에서 v로 가는 일방통행 길인 것이고, b가 1일 경우 u와 v를 잇는 양방향 길이다.

어떤 두 건물 사이를 잇는 길은 최대 한 개이다.

다음 줄에 학생들의 질문의 수 k가 주어진다. (1 ≤ k ≤ 30,000)

다음 k줄에 걸쳐 s e (1 ≤ s ≤ n, 1 ≤ e ≤ n)의 형태로 학생들의 질문들이 주어진다.

이는 질문한 학생이 건물 s에서 건물 e로 가고 싶다는 의미이다.

출력

출력은 k줄에 걸쳐 이루어진다.

각 질문에 대해, 최소 몇 개의 일방통행인 길을 양방향 통행으로 바꿔야 출발지에서 도착지로 갈 수 있는지를 출력한다.

모든 길을 양방향으로 바꾸더라도 서로 도달 불가능한 건물은 없다.

예제 입력 1

예제 출력 1

출처

University > 연세대학교 > 2015 연세대학교 프로그래밍 경시대회 F번

문제를 만든 사람: portableangel

알고리즘 분류

접근 방법

시간 초과 코드 (DFS)

DFS 탐색을 이용하여 도착지부터 출발지까지 최소 거리를 카운트하여 탐색한 코드

#include 
#include 
#include 

using namespace std;

constexpr int INF = INT32_MAX / 2;

constexpr int MAX = 251;

vector> graph[MAX];

list> myList;

int disArr[MAX][MAX];
bool check[MAX];

// N : 도시의 수, M : 길의 수
int N, M, s, d, w, b, K, result;

void Tracking(int start, int now, int cnt)
{
	if (start == now || disArr[now][start] == 0) {
		result = min(result, cnt);
		return;
	}

	for (int j = 0; j < graph[now].size(); j++) {
		int v = graph[now][j].first; // 도착점
		int weight = graph[now][j].second; // 가중치

		if (check[v] == true) continue;

		if (weight == INF) {
			cnt++;
			check[v] = true;
			Tracking(start, v, cnt);
			check[v] = false;
			cnt--;	
		}
		else
		{
			check[v] = true;
			Tracking(start, v, cnt);
			check[v] = false;
		}
	}
}


int main()
{
	ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
	// cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
	cin.tie(NULL);
	cout.tie(NULL);

	cin >> N >> M;

	// 길의 정보를 입력
	for (int i = 0; i < M; i++) {

		// 출발 s, 도착 d, b 양/단 방향
		cin >> s >> d >> b;

		if (b == 0) { // 단방향
			graph[s].push_back(make_pair(d, 0));
			graph[d].push_back(make_pair(s, INF));
		}
		else { // 양방향
			graph[s].push_back(make_pair(d, 0));
			graph[d].push_back(make_pair(s, 0));
		}

	}

	// 질문을 입력 받는다.
	cin >> K;
	pair tempP;
	while (K--) {
		cin >> tempP.first >> tempP.second;
		myList.push_back(tempP);
	}




	// 최단 거리 배열 disArr 배열을 INF 초기화
	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= N; j++) {

			if (i == j) disArr[i][j] = 0;
			else disArr[i][j] = INF;

		}
	}

	for (int i = 1; i <= N; i++) { // 시작 정점
		for (int j = 0; j < graph[i].size(); j++) {

			int v = graph[i][j].first; // 도착점
			int weight = graph[i][j].second; // 가중치

			if (disArr[i][v] > weight) 	disArr[i][v] = weight;

		}
	}

	// 무지성 플로이드
	for (int k = 1; k <= N; k++) {
		for (int i = 1; i <= N; i++) {
			for (int j = 1; j <= N; j++) {

				if (i == j) disArr[i][j] = 0;
				else disArr[i][j] = min(disArr[i][j], disArr[i][k] + disArr[k][j]);

			}
		}
	}

	for (auto it = myList.begin(); it != myList.end(); it++) {
		result = INF;
		if (disArr[it->first][it->second] == 0) cout << disArr[it->first][it->second] << "\n";
		else {
			Tracking(it->second, it->first, 0);
			cout << result << "\n";
		}
	}

	return 0;
}

통과된 코드

Floyd-Warshall 알고리즘이 어떤 식으로 작동하는지 안다면 뒤집는 부분에 왜 1 이 들어가는지 알 수 있다.

#include 
#include 
#include 

using namespace std;

constexpr int INF = INT32_MAX / 2;

constexpr int MAX = 251;

vector> graph[MAX];

list> myList;

int disArr[MAX][MAX];

// N : 도시의 수, M : 길의 수
int N, M, s, d, w, b, K, result;

int main()
{
	ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
	// cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
	cin.tie(NULL);
	cout.tie(NULL);

	cin >> N >> M;

	// 최단 거리 배열 disArr 배열을 INF 초기화
	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= N; j++) {
			disArr[i][j] = INF;
		}
	}

	// 길의 정보를 입력
	for (int i = 0; i < M; i++) {

		// 출발 s, 도착 d, b 양/단 방향
		cin >> s >> d >> b;

		if (b == 0) { // 단방향
			graph[s].push_back(make_pair(d, 0));
			disArr[d][s] = 1; // (disArr[i][k] + disArr[k][j] vs INF)
		}
		else { // 양방향
			graph[s].push_back(make_pair(d, 0));
			graph[d].push_back(make_pair(s, 0));
		}

	}

	// 질문을 입력 받는다.
	cin >> K;

	pair tempP;

	while (K--) {
		cin >> tempP.first >> tempP.second;
		myList.push_back(tempP);
	}

	for (int i = 1; i <= N; i++) { // 시작 정점
		for (int j = 0; j < graph[i].size(); j++) {

			int v = graph[i][j].first; // 도착점
			int weight = graph[i][j].second; // 가중치
			if (disArr[i][v] > weight) disArr[i][v] = weight;
		}
	}

	// 무지성 플로이드
	for (int k = 1; k <= N; k++) {
		for (int i = 1; i <= N; i++) {
			for (int j = 1; j <= N; j++) {

				if (i == j) disArr[i][j] = 0;
				else disArr[i][j] = min(disArr[i][j], disArr[i][k] + disArr[k][j]);

			}
		}
	}

	for (auto it = myList.begin(); it != myList.end(); it++) {
		cout << disArr[it->first][it->second] << "\n";		
	}

	return 0;
}

The post 백준 11562번 (백양로 브레이크, C++, Floyd-Warshall) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

백준 11404번 (플로이드, C++, Floyd-Warshall) [BAEKJOON]

lycos7560 — Fri, 17 Feb 2023 02:12:37 +0000

목차 테이블

플로이드
접근 방법
통과된 코드

플로이드

https://www.acmicpc.net/problem/11404

시간 제한	메모리 제한	제출	정답	맞힌 사람	정답 비율
1 초	256 MB	50776	21108	14907	41.664%

문제

n(2 ≤ n ≤ 100)개의 도시가 있다.

그리고 한 도시에서 출발하여 다른 도시에 도착하는 m(1 ≤ m ≤ 100,000)개의 버스가 있다.

각 버스는 한 번 사용할 때 필요한 비용이 있다.

모든 도시의 쌍 (A, B)에 대해서 도시 A에서 B로 가는데 필요한 비용의 최솟값을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 도시의 개수 n이 주어지고 둘째 줄에는 버스의 개수 m이 주어진다.

그리고 셋째 줄부터 m+2줄까지 다음과 같은 버스의 정보가 주어진다.

먼저 처음에는 그 버스의 출발 도시의 번호가 주어진다.

버스의 정보는 버스의 시작 도시 a, 도착 도시 b, 한 번 타는데 필요한 비용 c로 이루어져 있다.

시작 도시와 도착 도시가 같은 경우는 없다.

비용은 100,000보다 작거나 같은 자연수이다.

시작 도시와 도착 도시를 연결하는 노선은 하나가 아닐 수 있다.

출력

n개의 줄을 출력해야 한다.

i번째 줄에 출력하는 j번째 숫자는 도시 i에서 j로 가는데 필요한 최소 비용이다.

만약, i에서 j로 갈 수 없는 경우에는 그 자리에 0을 출력한다.

예제 입력 1

예제 출력 1

0 2 3 1 4
12 0 15 2 5
8 5 0 1 1
10 7 13 0 3
7 4 10 6 0

출처

문제의 오타를 찾은 사람: algoshipda
문제를 만든 사람: baekjoon
빠진 조건을 찾은 사람: dbfldkfdbgml, koosaga
데이터를 추가한 사람: dlwocks31, kyaryunha_cpp

알고리즘 분류

접근 방법

통과된 코드

#include 
#include 

using namespace std;

constexpr int INF = INT32_MAX/2; // overflow 조

constexpr int MAX = 101;

vector> graph[MAX];

int disArr[MAX][MAX];

// N : 도시의 수, M : 버스의 수
int N, M, s, d, w;

int main()
{	
	ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
	// cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
	cin.tie(NULL);
	cout.tie(NULL);

	cin >> N >> M;

	// 노선을 입력
	for (int i = 0; i < M; i++) {

		// 단방향 교통수단 출발 s, 도착 d, 비용 w
		cin >> s >> d >> w;

		graph[s].push_back(make_pair(d, w));
	}

	// 최단 거리 배열 disArr 배열을 INF 초기화
	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= N; j++) {

			if (i == j) disArr[i][j] = 0;
			else disArr[i][j] = INF;

		}
	}

	for (int i = 1; i <= N; i++) { // 시작 정점
		for (int j = 0; j < graph[i].size(); j++) {

			int v = graph[i][j].first; // 도착점
			int weight = graph[i][j].second; // 가중치

			if (disArr[i][v] > weight) 	disArr[i][v] = weight;

		}
	}
	
	// 무지성 플로이드
	for (int k = 1; k <= N; k++) {
		for (int i = 1; i <= N; i++) {
			for (int j = 1; j <= N; j++) {

				if (i == j) disArr[i][j] = 0;
				else disArr[i][j] = min(disArr[i][j], disArr[i][k] + disArr[k][j]);

			}
		}
	}

	// 결과 출력
	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= N; j++) {

			if (disArr[i][j] == INF) cout << 0 << " ";
			else cout << disArr[i][j] << " ";

		}

		cout << "\n";

	}

	return 0;
}

The post 백준 11404번 (플로이드, C++, Floyd-Warshall) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

백준 1219번 (오민식의 고민, C++, Bellman–Ford) [BAEKJOON]

lycos7560 — Sun, 12 Feb 2023 18:38:37 +0000

목차 테이블

오민식의 고민
주의 사항
통과된 코드
추가 반례

오민식의 고민

https://www.acmicpc.net/problem/1219

시간 제한	메모리 제한	제출	정답	맞힌 사람	정답 비율
2 초	128 MB	10997	2142	1250	16.718%

문제

오민식은 세일즈맨이다.

오민식의 회사 사장님은 오민식에게 물건을 최대한 많이 팔아서 최대 이윤을 남기라고 했다.

오민식은 고민에 빠졌다. 어떻게 하면 최대 이윤을 낼 수 있을까?

이 나라에는 N개의 도시가 있다. 도시는 0번부터 N-1번까지 번호 매겨져 있다.

오민식의 여행은 A도시에서 시작해서 B도시에서 끝난다.

오민식이 이용할 수 있는 교통수단은 여러 가지가 있다.

오민식은 모든 교통수단의 출발 도시와 도착 도시를 알고 있고, 비용도 알고 있다.

게다가, 오민식은 각각의 도시를 방문할 때마다 벌 수 있는 돈을 알고있다.

이 값은 도시마다 다르며, 액수는 고정되어있다. 또, 도시를 방문할 때마다 그 돈을 벌게 된다.

오민식은 도착 도시에 도착할 때, 가지고 있는 돈의 액수를 최대로 하려고 한다.

이 최댓값을 구하는 프로그램을 작성하시오.

오민식이 버는 돈보다 쓰는 돈이 많다면, 도착 도시에 도착할 때 가지고 있는 돈의 액수가 음수가 될 수도 있다.

또, 같은 도시를 여러 번 방문할 수 있으며, 그 도시를 방문할 때마다 돈을 벌게 된다.

모든 교통 수단은 입력으로 주어진 방향으로만 이용할 수 있으며, 여러 번 이용할 수도 있다.

입력

첫째 줄에 도시의 수 N과 시작 도시, 도착 도시 그리고 교통 수단의 개수 M이 주어진다.

둘째 줄부터 M개의 줄에는 교통 수단의 정보가 주어진다.

교통 수단의 정보는 “시작 끝 가격”과 같은 형식이다.

마지막 줄에는 오민식이 각 도시에서 벌 수 있는 돈의 최댓값이 0번 도시부터 차례대로 주어진다.

N과 M은 50보다 작거나 같고, 돈의 최댓값과 교통 수단의 가격은 1,000,000보다 작거나 같은 음이 아닌 정수이다.

출력

첫째 줄에 도착 도시에 도착할 때, 가지고 있는 돈의 액수의 최댓값을 출력한다.

만약 오민식이 도착 도시에 도착하는 것이 불가능할 때는 “gg”를 출력한다.

그리고, 오민식이 도착 도시에 도착했을 때 돈을 무한히 많이 가지고 있을 수 있다면 “Gee”를 출력한다.

예제 입력 1

예제 출력 1

-32

예제 입력 2

5 0 4 5
0 1 10
1 2 10
2 3 10
3 1 10
2 4 10
0 10 10 110 10

예제 출력 2

Gee

예제 입력 3

3 0 2 3
0 1 10
1 0 10
2 1 10
1000 1000 47000

예제 출력 3

gg

예제 입력 4

예제 출력 4

Gee

예제 입력 5

1 0 0 1
0 0 10
7

예제 출력 5

예제 입력 6

5 0 4 7
0 1 13
1 2 17
2 4 20
0 3 22
1 3 4747
2 0 10
3 4 10
8 10 20 1 100000

예제 출력 6

출처

문제를 번역한 사람: baekjoon
잘못된 조건을 찾은 사람: djm03178
데이터를 추가한 사람: gkgg123, sait2000
문제의 오타를 찾은 사람: jh05013, typhoon

알고리즘 분류

주의 사항

순환이 도착 지점에 영향을 줄 수 있도록 많은 시도가 필요하다.

통과된 코드

#include 
#include 

using namespace std;

constexpr int MAXN = 50;

constexpr long long int INF = -INT64_MAX;

long long int disArr[MAXN];

int N, S, D, M, V, U, W, G[MAXN];

bool check = false;

vector> graph[MAXN];

int main()
{
    ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
    // cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
    cin.tie(NULL);
    std::cout.tie(NULL);

    cin >> N >> S >> D >> M;

    // 교통 수단을 입력받는다.
    for (int i = 0; i < M; i++) {
        cin >> V >> U >> W;
        // 단방향 교통수단 출발, 도착, 비용
        graph[V].push_back(make_pair(U, -W));
    }

    // 도시에서 버는 비용입력
    for (int i = 0; i < N; i++) cin >> G[i];

    fill(disArr, disArr + MAXN, INF);

    disArr[S] = G[S];

    // N번 이후부터는 순환 체크
    // 순환이 있는지 충분히 확인
    for (int k = 1; k <= N * 2; k++) { 
        for (int i = 0; i < N; i++) { // 시작 정점
            for (int j = 0; j < graph[i].size(); j++) {
                int v = graph[i][j].first; // 도착점
                int weight = graph[i][j].second; // 가중치

                if (disArr[i] == -INF) disArr[v] = -INF; // 출발지가 순환이라면 도착지도 순환
                else if (disArr[i] != INF && disArr[i] + weight + G[v] > disArr[v]) {
                    disArr[v] = disArr[i] + weight + G[v]; // 업데이트

                    if (k >= N) disArr[v] = -INF; // 순환찾기
                }
            }
        }
    }

    if (disArr[D] == -INF) cout << "Gee"; // 순환에 포함
    else if (disArr[D] == INF) cout << "gg"; // 도착 불가능 
    else cout << disArr[D];

    return 0;

}

추가 반례

예제 입력 A

예제 출력 A

Gee

예제 입력 B

5 0 0 0
1 2 3 4 5

예제 출력 B

예제 입력 C

50 0 49 50
0 1 0
1 2 0
2 3 0
3 4 0
4 5 0
5 6 0
6 7 0
7 8 0
8 9 0
9 10 0
10 11 0
11 12 0
12 13 0
13 14 0
14 15 0
15 16 0
16 17 0
17 18 0
18 19 0
19 20 0
20 21 0
21 22 0
22 23 0
23 24 0
24 25 0
25 26 0
26 27 0
27 28 0
28 29 0
29 30 0
30 31 0
31 32 0
32 33 0
33 34 0
34 35 0
35 36 0
36 37 0
37 38 0
38 39 0
39 40 0
40 41 0
41 42 0
42 43 0
43 44 0
44 45 0
45 46 0
46 47 0
47 48 0
48 49 0
49 0 0
1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000

예제 출력 C

Gee

예제 입력 D

예제 출력 D

예제 입력 E

예제 출력 E

예제 입력 F

5 0 4 5
0 1 10
1 2 10
2 3 10
3 1 10
2 4 10
0 10 10 110 10

예제 출력 F

Gee

The post 백준 1219번 (오민식의 고민, C++, Bellman–Ford) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

백준 1865번 (웜홀, C++, Bellman–Ford) [BAEKJOON]

lycos7560 — Sun, 12 Feb 2023 14:53:28 +0000

목차 테이블

웜홀
풀이 방법
풀이에 도움되는 글
통과된 코드

웜홀

https://www.acmicpc.net/problem/1865

시간 제한	메모리 제한	제출	정답	맞힌 사람	정답 비율
2 초	128 MB	36111	8293	5117	21.896%

문제

때는 2020년, 백준이는 월드나라의 한 국민이다.

월드나라에는 N개의 지점이 있고 N개의 지점 사이에는 M개의 도로와 W개의 웜홀이 있다.

(단 도로는 방향이 없으며 웜홀은 방향이 있다.)

웜홀은 시작 위치에서 도착 위치로 가는 하나의 경로인데,

특이하게도 도착을 하게 되면 시작을 하였을 때보다 시간이 뒤로 가게 된다.

웜홀 내에서는 시계가 거꾸로 간다고 생각하여도 좋다.

시간 여행을 매우 좋아하는 백준이는 한 가지 궁금증에 빠졌다.

한 지점에서 출발을 하여서 시간여행을 하기 시작하여 다시 출발을 하였던 위치로 돌아왔을 때,

출발을 하였을 때보다 시간이 되돌아가 있는 경우가 있는지 없는지 궁금해졌다.

여러분은 백준이를 도와 이런 일이 가능한지 불가능한지 구하는 프로그램을 작성하여라.

입력

첫 번째 줄에는 테스트케이스의 개수 TC(1 ≤ TC ≤ 5)가 주어진다.

그리고 두 번째 줄부터 TC개의 테스트케이스가 차례로 주어지는데 각 테스트케이스의 첫 번째 줄에는

지점의 수 N(1 ≤ N ≤ 500), 도로의 개수 M(1 ≤ M ≤ 2500), 웜홀의 개수 W(1 ≤ W ≤ 200)이 주어진다.

그리고 두 번째 줄부터 M+1번째 줄에 도로의 정보가 주어지는데 각 도로의 정보는 S, E, T 세 정수로 주어진다.

S와 E는 연결된 지점의 번호, T는 이 도로를 통해 이동하는데 걸리는 시간을 의미한다.

그리고 M+2번째 줄부터 M+W+1번째 줄까지 웜홀의 정보가 S, E, T 세 정수로 주어지는데

S는 시작 지점, E는 도착 지점, T는 줄어드는 시간을 의미한다.

T는 10,000보다 작거나 같은 자연수 또는 0이다.

두 지점을 연결하는 도로가 한 개보다 많을 수도 있다.

지점의 번호는 1부터 N까지 자연수로 중복 없이 매겨져 있다.

출력

TC개의 줄에 걸쳐서 만약에 시간이 줄어들면서 출발 위치로 돌아오는 것이 가능하면 YES, 불가능하면 NO를 출력한다.

예제 입력 1

예제 출력 1

NO
YES

출처

Olympiad > USA Computing Olympiad > 2006-2007 Season > USACO December 2006 Contest > Gold 1번

데이터를 추가한 사람: artichoke42, jh05013

알고리즘 분류

풀이 방법

풀이에 도움되는 글

https://www.acmicpc.net/board/view/72995 <- jh05013의 설명

이 문제에는 여러 우여곡절의 역사가 있습니다.

그래서인지 시작점이 어디라는 언급이 전혀 없는데도 인터넷에 있는 거의 모든 풀이가 1을 시작 정점으로 잡고,

원래 dist[v] != INF이 들어가야 최단거리가 제대로 구해지는데 이걸 오히려 빼버리는 데다가,

왜 이걸 빼야 정답을 받는지는 설명을 안 하고 있습니다.

1. 백준이가 출발을 어디서 하는가?

아무데서나 출발할 수 있습니다.

2. 왜 시작 정점을 1로 정해도 풀리는가?

방금도 언급했듯이 인터넷에 있는 거의 모든 풀이는 아래의 “코드 1″처럼 구현하고 있습니다.

그런데도 맞았습니다!!를 받는데, 그건 잘못된 구현이 오히려 이 문제에서는 올바른 풀이가 되어서 그렇습니다.

바로 dist[v] != INF를 검사하지 않는 것입니다. “코드 2″와 비교해 보세요.

코드 1은 “dist[v] == INF”를 “v를 방문하지 않았다”가 아니라 “v를 방문했고,

v까지의 최단거리가 INF다”로 인식하고 있습니다.

그래서 이 코드는 이미 처음부터 모든 정점을 방문한 걸로 착각을 하게 되는데,

덕분에 음수 사이클이 어디에 있든 항상 도달이 가능하기 때문에 정답을 받습니다.

어차피 모든 정점을 처음부터 방문하니까, dist[1] = 0은 이 코드에서는 아무 의미가 없습니다.

dist[3] = 0을 하거나, 아예 이 줄을 빼도 맞습니다.

그렇다면 코드 1이 항상 코드 2보다 좋은 코드이냐? 그렇지 않습니다.

코드 1에서는 어떤 정점이 실제로 도달 가능한 정점인지 알 수 없기 때문에, 코드 1은 올바른 벨만 포드 구현이 아닙니다.

(즉 v가 실제로 도달 불가능한 정점이더라도 dist[v] != INF일 수 있습니다.)

단지 그 정보가 이 문제에서는 필요 없기 때문에 맞는 것뿐이고,

만약 문제가 “각 점까지의 최단거리를 구해라”였다면 코드 2처럼 하는 것이 좋습니다.

2-1. 코드 2는 왜 틀리는가?

아래의 “코드 2″처럼 구현했다면 오답 처리가 될 것입니다.

틀려야 되는 이유는 시작 정점으로부터 도달할 수 없는 음수 사이클을 못 찾기 때문입니다.

다시 말하면, 이렇게 구현했을 경우 한 점에서만 출발하면 안 됩니다.

2-2. 파이썬 float(‘inf’)

float(‘inf’)에 음수를 더해도 여전히 float(‘inf’)이기 때문에, 이 경우에는 거리 갱신이 이루어지지 않습니다.

그래서 이 경우는 코드 2와 똑같이 동작합니다.

2-3. 그럼 제 강의 자료가 틀린 건가요?

당장 위키피디아만 봐도 dist[v] != INF 같은 게 안 보이지만, 그렇다고 그 자료가 틀린 건 아닙니다.

일반적으로, 알고리즘 설명이나 수도코드에서 ∞ 같은 게 나오면 “아주 큰 수”가 아니라 진짜로 무한대입니다.

파이썬으로 치면 float(‘inf’)와 같습니다.

진짜로 무한대면 dist[v]가 ∞인지 여부와 관계없이 거리 갱신을 다 해도 상관없습니다.

실제로 구현할 때는 “무한히 큰 int”같은 건 없으니까,

도달을 아직 못 한 점에서는 거리 갱신을 안 하는 식으로 우회하는 것일 뿐입니다.

3. 두 번째 방법으로 구현했으면 어떻게 풀어야 하는가?

두 가지 방법이 있습니다.

시작 정점이 한 개일 필요는 없습니다. 모든 정점에서 “동시에” 시작할 수 있습니다.
그러려면 거리 배열 전체를 INF가 아닌 0으로 초기화하고 벨만 포드를 돌리면 됩니다.
그래도 꼭 시작 정점이 단 하나였으면 좋겠다고 생각하신다면, N+1번째 “가짜 정점”을 만들어서
나머지 모든 정점으로 가중치 0의 간선을 긋고, 시작 정점을 N+1로 잡으면 됩니다.
그러면 모든 정점이 도달 가능하므로 음수 사이클이 어디에 있든 항상 찾을 수 있습니다.

코드 1
INF = 2000000000
모든 dist[v] = INF
dist[1] = 0
N-1번 반복:
  모든 v에 대해:
    모든 간선에 대해 최단거리 갱신
모든 v에 대해:
  모든 간선에 대해 최단거리 갱신
  갱신이 한 번이라도 일어났으면 true

===

코드 2
INF = 2000000000
모든 dist[v] = INF
dist[1] = 0
N-1번 반복:
  dist[v] != INF인 모든 v에 대해:
    모든 간선에 대해 최단거리 갱신
dist[v] != INF인 모든 v에 대해:
  모든 간선에 대해 최단거리 갱신
  갱신이 한 번이라도 일어났으면 true

통과된 코드

#include 
#include 

using namespace std;

constexpr int MAXN = 501;

int disArr[MAXN];

int TC, N, M, W, S, E, T;

vector> graph[MAXN];

bool BellmanFord()
{
	cin >> N >> M >> W;

	vector> graph[MAXN];

	// 도로의 정보를 입력받는다.
	for (int i = 0; i < M; i++) {
		cin >> S >> E >> T;
		// 양방향
		graph[S].push_back(make_pair(E, T));
		graph[E].push_back(make_pair(S, T));
	}

	// 웜홀의 정보를 입력받는다.
	for (int i = 0; i < W; i++) {
		cin >> S >> E >> T;
		// 단방향
		graph[S].push_back(make_pair(E, -T));
	}

	// 출발은 어디에새 해도 상관이 없다.
	fill(disArr, disArr + MAXN, 0);

	// (모든 정점의 수 - 1) 번 확인한다.
	// N 번은 순환 체크
	for (int k = 1; k <= N; k++) {
		for (int i = 1; i <= N; i++) { // 시작 정점
			for (int j = 0; j < graph[i].size(); j++) {
				int v = graph[i][j].first; // 도착점
				int weight = graph[i][j].second; // 가중치
	
				// 시작 임시 배열의 가중치가 도착지의 가중치보다 크다면
				if (disArr[i] + weight < disArr[v]) {
					disArr[v] = disArr[i] + weight;

					// K == N 일때 새로 업데이트 된다는 의미
					if (k == N) return true; // 순환이 있음
					
				}
			}
		}
	}

	return false;
	// 순환이 없음
}

int main()
{
	ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
	// cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
	cin.tie(NULL);
	std::cout.tie(NULL);

	cin >> TC;

	for (int i = 0; i < TC; i++) {

		if (BellmanFord()) cout << "YES\n";
		else cout << "NO\n";

	}

	return 0;
}

The post 백준 1865번 (웜홀, C++, Bellman–Ford) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

백준 1738번 (골목길, C++, Bellman–Ford) / 추가 반례 [BAEKJOON]

lycos7560 — Sat, 11 Feb 2023 01:19:36 +0000

목차 테이블

골목길
주의 사항
통과된 코드
추가 반례

골목길

https://www.acmicpc.net/problem/1738

시간 제한	메모리 제한	제출	정답	맞힌 사람	정답 비율
2 초	128 MB	5531	932	552	17.824%

문제

민승이는 놀러가기 위해 집을 나섰다.

민승이네 집에서 코레스코 콘도까지 가기 위해서는 복잡하게 얽혀있는 골목길들을 통과해야 한다.

그런데, 어떤 길에는 깡패가 서식하고 있어, 그 길을 지나게 되면 깡패에게 일정한 양의 금품을 갈취당하게 된다.

그런가하면, 어떤 길에는 지나가던 행인들이 흘리고 간 금품들이 떨어져 있어, 그 길을 지나게 되면 일정한 양의 금품을 획득하게 된다.

한 번 지나간 길을 다시 방문하더라도 금품을 갈취당하거나 획득한다.

골목길의 연결 상태와, 각 골목길을 지날 때 갈취당하거나 획득하게 되는 금품의 양이 주어졌을 때,

민승이가 최대한 유리한 경로를 따라 집에서 코레스코 콘도까지 가기 위해서는 어떻게 해야 하는지 출력하는 프로그램을 작성하시오.

보유 중인 금품의 양이 음수가 될 수 있다.

최대한 유리한 경로 또는 최적의 경로는 민승이네 집에서 출발하여 코레스코 콘도에 도착하는 경로 중 금품의 양이 최대가 되는 경로이다.

입력

첫째 줄에 골목길들이 교차하는 지점의 개수 n (2 ≤ n ≤ 100)과

골목길의 개수 m (1 ≤ m ≤ 20,000) 이 차례로 주어진다.

이어지는 m개의 행에 각각의 골목길을 나타내는 세 정수 u, v, w가 차례로 주어진다.

이는 u번 교차점에서 v번 교차점으로 이동할 수 있는 골목길이 나있다는 의미이다.

즉, 주어지는 골목길들은 기본적으로 모두 일방통행로이다.

w (0 ≤ |w| ≤ 1,000)는 이 길을 지날 때 갈취당하거나 획득하게 되는 금품의 양이다.

음수는 갈취, 양수는 획득을 뜻한다.

골목길의 교차점 번호는 1이상 n이하의 정수이다.

민승이네 집은 1번 교차점에 있고, 이곳 코레스코 콘도는 n번 교차점에 있다.

출력

최적의 경로를 구할 수 있다면 민승이네 집부터 코레스코 콘도까지 가는 동안 거치게 되는

교차점들의 번호를 공백 하나를 사이에 두고 차례로 출력하면 된다.

그런데, 경우에 따라서는 최적의 경로라는 것이 존재하지 않는 상황이 발생한다.

어떠한 경우에 그런 상황이 발생하는지 생각해 보자.

그러한 경우에는 -1을 출력하도록 한다.

최적의 경로가 여러 개 존재할 때는 아무거나 출력해도 된다.

예제 입력 1

예제 출력 1

1 2 3 4 5

예제 입력 2

예제 출력 2

-1

출처

문제를 번역한 사람: author10
빠진 조건을 찾은 사람: kcm1700

알고리즘 분류

알고리즘 – 벨만-포드 (Bellman–Ford Algorithm) 알고리즘 정리

주의 사항

이 문제는 Bellman–Ford 알고리즘을 사용할 때 사이클이 있다고 해서 무조건 -1 을 출력하면 안된다.

해당 사이클이 최적의 경로에 영향이 있는지 확인이 필요하다.

통과된 코드

#include 
#include 

using namespace std;

constexpr long long int INF = INT64_MAX;

constexpr int MAXN = 101;

vector> graph[MAXN];

long long int disArr[MAXN];

// N : 지점의 개수, M : 골목길의 개수
int N, M, u, v, w;

int trace[MAXN];

int main()
{

	ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
	// cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
	cin.tie(NULL);
	std::cout.tie(NULL);

	cin >> N >> M;

	fill(disArr, disArr + MAXN, INF);

	disArr[1] = 0;

	for (int i = 0; i < M; i++) {
		cin >> u >> v >> w;
		// 단방향
		graph[u].push_back(make_pair(v, -w));
	}


	// (모든 정점의 수 - 1) 번 확인한다.
	// N 번은 순환 체크
	for (int k = 1; k <= N; k++) {
		for (int i = 1; i <= N; i++) {
			for (int j = 0; j < graph[i].size(); j++) {

				int u = i; // 시작점
				int v = graph[i][j].first; // 도착점
				int weight = graph[i][j].second; // 가중치

				// 만약 임시 배열이 무한대가 아니고 &&
				// 시작 임시 배열의 가중치가 도착지의 가중치보다 크다면
				if (disArr[u] != INF && disArr[u] + weight < disArr[v]) {
					disArr[v] = disArr[u] + weight;
					trace[v] = u;

					// K == N 일때 새로 업데이트 된다는 의미는 
					// 사이클에 포함되거나 사이클에서 도착 지점으로 도달 가능
					// 다음의 disArr[N] == -INF 코드를 통하여 영향이 있는 경로인지 판별 
					if (k == N) disArr[v] = -INF;
					// -INF로 더이상 업데이트를 막는다.
				}
			}
		}
	}

	if (disArr[N] == INF || disArr[N] == -INF) cout << "-1";
	else {
		// 경로를 역으로 추적한다.
		int now = N;
		vector myV;
		while (now != 0) {
			myV.push_back(now);
			now = trace[now]; 
		}

		for (auto it = myV.rbegin(); it != myV.rend(); ++it) cout << *it << " ";

	}

	return 0;
}

추가 반례

예제 입력 A

예제 출력 A

1 4

예제 입력 B

예제 출력 B

-1

예제 입력 C

예제 출력 C

1 2 5

예제 입력 D

예제 출력 D

-1

예제 입력 E

예제 출력 E

1 4

예제 입력 F

예제 출력 F

-1

예제 입력 G

예제 출력 G

-1

예제 입력 H

예제 출력 H

1 2 5

The post 백준 1738번 (골목길, C++, Bellman–Ford) / 추가 반례 [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

백준 11657번 (타임머신, C++, Bellman–Ford) [BAEKJOON]

lycos7560 — Fri, 10 Feb 2023 17:54:24 +0000

목차 테이블

타임머신
풀이 과정
통과된 코드

타임머신

https://www.acmicpc.net/problem/11657

시간 제한	메모리 제한	제출	정답	맞힌 사람	정답 비율
1 초	256 MB	48876	10037	6258	22.768%

문제

N개의 도시가 있다.

그리고 한 도시에서 출발하여 다른 도시에 도착하는 버스가 M개 있다.

각 버스는 A, B, C로 나타낼 수 있는데, A는 시작도시, B는 도착도시, C는 버스를 타고 이동하는데 걸리는 시간이다.

시간 C가 양수가 아닌 경우가 있다.

C = 0인 경우는 순간 이동을 하는 경우, C < 0인 경우는 타임머신으로 시간을 되돌아가는 경우이다.

1번 도시에서 출발해서 나머지 도시로 가는 가장 빠른 시간을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 도시의 개수 N (1 ≤ N ≤ 500), 버스 노선의 개수 M (1 ≤ M ≤ 6,000)이 주어진다.

둘째 줄부터 M개의 줄에는 버스 노선의 정보 A, B, C (1 ≤ A, B ≤ N, -10,000 ≤ C ≤ 10,000)가 주어진다.

출력

만약 1번 도시에서 출발해 어떤 도시로 가는 과정에서 시간을 무한히 오래 전으로 되돌릴 수 있다면 첫째 줄에 -1을 출력한다.

그렇지 않다면 N-1개 줄에 걸쳐 각 줄에 1번 도시에서 출발해 2번 도시, 3번 도시, …, N번 도시로 가는 가장 빠른 시간을 순서대로 출력한다.

만약 해당 도시로 가는 경로가 없다면 대신 -1을 출력한다.

예제 입력 1

예제 출력 1

4
3

예제 입력 2

예제 출력 2

-1

예제 입력 3

3 2
1 2 4
1 2 3

예제 출력 3

3
-1

출처

어색한 표현을 찾은 사람: alex9801, myungwoo, rim
문제를 만든 사람: baekjoon
데이터를 추가한 사람: djm03178, doju, ganghe74

알고리즘 분류

알고리즘 – 벨만-포드 (Bellman–Ford Algorithm) 알고리즘 정리

풀이 과정

통과된 코드

#include 
#include 

using namespace std;

constexpr long long int INF = INT64_MAX;

constexpr int MAXN = 501;

long long int disArr[MAXN];

bool check = false; // 음의 순환이 있는지 확인

// N : 도시의 개수, M : 버스 노선의 개수
// A : 시작 도시, B : 도착 도시, C : 걸리는 시간
int N, M, A, B, C;

vector> graph[MAXN];

int main()
{
	ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
	// cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
	cin.tie(NULL);
	std::cout.tie(NULL);

	cin >> N >> M;

	for (int i = 0; i < M; i++) {
		cin >> A >> B >> C;
		// 단방향
		graph[A].push_back(make_pair(B, C));
	}

	// 배열 초기화
	fill(disArr, disArr + MAXN, INF);

	disArr[1] = 0;


	for (int k = 1; k <= N; k++) {// (모든 정점의 수 - 1) 번 확인한다.
		// 모든 노선을 확인한다.
		for (int i = 1; i <= N; i++) {
			for (int j = 0; j < graph[i].size(); j++) {

				int u = i; // 시작점
				int v = graph[i][j].first; // 도착점
				int weight = graph[i][j].second; // 가중치

				// 만약 임시 배열이 무한대가 아니고 &&
				// 시작 임시 배열의 가중치가 도착지의 가중치보다 작다면
				if (disArr[u] != INF && disArr[u] + weight < disArr[v]) {

					disArr[v] = disArr[u] + weight; // 임시배열을 업데이트 해준다.

					// K가 N-1일때 모든 정점을 확인한 후
					// K가 N일때 업데이트가 있다면 음의 순환이 있다는 이야기
					if (k == N) { 
						cout << "-1";
						return 0;
					}
				}
			}
		}
	}

	for (int i = 2; i <= N; i++) {
		if (disArr[i] == INF) cout << "-1" << "\n";
		else cout << disArr[i] << "\n";
	}

	return 0;
}

The post 백준 11657번 (타임머신, C++, Bellman–Ford) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

백준 5719번 (거의 최단 경로, C++, Dijkstra) / 추가 반례 [BAEKJOON]

lycos7560 — Sun, 05 Feb 2023 13:45:54 +0000

목차 테이블

거의 최단 경로
추가 예제
틀린 코드 (메모리 초과)
통과된 코드

거의 최단 경로

https://www.acmicpc.net/problem/5719

시간 제한	메모리 제한	제출	정답	맞힌 사람	정답 비율
1 초	256 MB	23040	3945	2400	19.151%

문제

요즘 많은 자동차에서는 GPS 네비게이션 장비가 설치되어 있다.

네비게이션은 사용자가 입력한 출발점과 도착점 사이의 최단 경로를 검색해 준다.

하지만, 교통 상황을 고려하지 않고 최단 경로를 검색하는 경우에는 극심한 교통 정체를 경험할 수 있다.

상근이는 오직 자기 자신만 사용 가능한 네비게이션을 만들고 있다.

이 네비게이션은 절대로 최단 경로를 찾아주지 않는다. 항상 거의 최단 경로를 찾아준다.

거의 최단 경로란 최단 경로에 포함되지 않는 도로로만 이루어진 경로 중 가장 짧은 것을 말한다.

예를 들어, 도로 지도가 아래와 같을 때를 생각해보자.

원은 장소를 의미하고, 선은 단방향 도로를 나타낸다.

시작점은 S, 도착점은 D로 표시되어 있다. 굵은 선은 최단 경로를 나타낸다. (아래 그림에 최단 경로는 두 개가 있다)

거의 최단 경로는 점선으로 표시된 경로이다.

이 경로는 최단 경로에 포함되지 않은 도로로 이루어진 경로 중 가장 짧은 경로이다.

거의 최단 경로는 여러 개 존재할 수도 있다.

예를 들어, 아래 그림의 길이가 3인 도로의 길이가 1이라면, 거의 최단 경로는 두 개가 된다.

또, 거의 최단 경로가 없는 경우도 있다.

입력

입력은 여러 개의 테스트 케이스로 이루어져 있다.

각 테스트 케이스의 첫째 줄에는 장소의 수 N (2 ≤ N ≤ 500)과 도로의 수 M (1 ≤ M ≤ 10⁴)가 주어진다.

장소는 0부터 N-1번까지 번호가 매겨져 있다. 둘째 줄에는 시작점 S와 도착점 D가 주어진다. (S ≠ D; 0 ≤ S, D < N)

다음 M개 줄에는 도로의 정보 U, V, P가 주어진다. (U ≠ V ; 0 ≤ U, V < N; 1 ≤ P ≤ 10³)

이 뜻은 U에서 V로 가는 도로의 길이가 P라는 뜻이다.

U에서 V로 가는 도로는 최대 한 개이다.

또, U에서 V로 가는 도로와 V에서 U로 가는 도로는 다른 도로이다.

입력의 마지막 줄에는 0이 두 개 주어진다.

출력

각 테스트 케이스에 대해서, 거의 최단 경로의 길이를 출력한다.

만약, 거의 최단 경로가 없는 경우에는 -1을 출력한다.

예제 출력 1

예제 입력 1

5
-1
6

출처

ICPC > Regionals > Latin America > South America Regional Contests 2008 A번

문제를 번역한 사람: baekjoon
데이터를 추가한 사람: gkswjdzz, sait2000, smsm8111
잘못된 데이터를 찾은 사람: tncks0121

알고리즘 분류

추가 예제

예제 출력 A

예제 출력 A

예제 입력 B

예제 출력 B

6
-1
-1
3

예제 입력 C

예제 출력 C

2
-1
-1
2

예제 입력 D

예제 출력 D

-1
3
2
-1

틀린 코드 (메모리 초과)

다익스트라의 경로를 저장하기 위하여 우선 순위 큐에 지나온 정점들을 list>에 담아 보았다.

당연하게 메모리 초과 (정답은 잘나온다… ㅜㅜ)

원리는 list에 있는 정점들을 방문처리하여 다음 다익스트라를 사용할 때 넘기는 방법을 사용했다.

#include 
#include 
#include 
#include 
#include 
#include 

using namespace std;

constexpr int INF = INT32_MAX;

int disArr[501];

bool check[501][501];

int N, M, S, D, U, V, P;

int Dijstra()
{
    int result = INF;

    for (int i = 0; i <= N; i++) {
        for (int j = 0; j <= N; j++) {
            check[i][j] = false;
        }
    }

    // 임시배열 초기화
    for (int i = 0; i <= N; i++) disArr[i] = INF;

    priority_queue>>> firstPQ;

    vector> graph[10000];

    list> myList;

    multimap>> myMap;

    for (int i = 0; i < M; i++) {
        cin >> U >> V >> P;
        graph[U].push_back(make_pair(V, P));
    }

    // 우선순위 큐에 삽입.
    firstPQ.push({ 0, S, myList }); // < first : 거리 , second : 노드 인덱스 >
    disArr[S] = 0;
    while (!firstPQ.empty()) {
        // -를 붙이는 이유는 우선순위 큐를 이용하여 정렬하기 위함이다.
        // (최소힙으로 구현)
        int nCost = -get<0>(firstPQ.top());
        int now = get<1>(firstPQ.top());
        myList = get<2>(firstPQ.top());
        firstPQ.pop();

        // 이미 담겨 있는 것보다 거리가 크면 넘어간다.
        if (disArr[now] < nCost) continue;

        // 해당 노드에서 연결된 모든 경로를 확인
        for (int i = 0; i < graph[now].size(); i++) {
            list> tempList = myList;
            // disSum = 임시 노드 + 현재 노드에서 i로가는 비용
            int disSum = nCost + graph[now][i].second;

            // 비용이 더 작다면 최단경로 테이블 값을 갱신.
            if (disSum <= disArr[graph[now][i].first]) {
                tempList.push_back(make_pair(now, graph[now][i].first));

                if (graph[now][i].first == D && result >= disSum) {
                    result = disSum;
                    myMap.insert(make_pair(disSum, tempList));
                }

                // 임시 노드 업데이트
                disArr[graph[now][i].first] = disSum;
                // 우선순위 큐에 (거리, 노드 인덱스) 푸시
                firstPQ.push(make_tuple(-disSum, graph[now][i].first, tempList));
            }
        }
    }

    result = disArr[D];

    for (auto mit = myMap.begin(); mit != myMap.end(); mit++) {
        if (result == mit->first) {
            for (auto it = mit->second.begin(); it != mit->second.end(); it++) {
                check[it->first][it->second] = true;
            }
        }

        else break;
    }

    priority_queue> myPQ;

    // 임시배열 초기화
    for (int i = 0; i <= N; i++) disArr[i] = INF;

    // 우선순위 큐에 삽입.
    myPQ.push({ 0, S }); // < first : 거리 , second : 노드 인덱스 >
    disArr[S] = 0;

    while (!myPQ.empty()) {
        // -를 붙이는 이유는 우선순위 큐를 이용하여 정렬하기 위함이다.
        // (최소힙으로 구현)
        int nCost = -myPQ.top().first;
        int now = myPQ.top().second;
        myPQ.pop();

        // 이미 담겨 있는 것보다 거리가 크면 넘어간다.
        if (disArr[now] < nCost) continue;
        // 해당 노드에서 연결된 모든 경로를 확인
        for (int i = 0; i < graph[now].size(); i++) {
            if (check[now][graph[now][i].first] == true) continue;
            // disSum = 임시 노드 + 현재 노드에서 i로가는 비용
            int disSum = nCost + graph[now][i].second;
            // 비용이 더 작다면 최단경로 테이블 값을 갱신.
            if (disSum <= disArr[graph[now][i].first]) {
                // 임시 노드 업데이트
                disArr[graph[now][i].first] = disSum;
                // 우선순위 큐에 (거리, 노드 인덱스) 푸시
                myPQ.push(make_pair(-disSum, graph[now][i].first));
            }
        }
    }

    return disArr[D];
}


int main()
{
    ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
    //cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
    cin.tie(NULL);
    std::cout.tie(NULL);

    while (true) {

        cin >> N >> M;

        if (N == 0 && M == 0) break;

        cin >> S >> D;

        int result = Dijstra();

        if (result == INF) cout << -1 << "\n";
        else cout << result << "\n";
    }



    return 0;
}

통과된 코드

vector trace[501]; 를 이용하여 시작과 끝의 정점들을 넣어준다.

주의할 점은 도착지에서 출발지 방향으로 탐색을 하기 위해서 반대로 넣어주어야 한다.

#include 
#include 
#include 

using namespace std;

constexpr int INF = INT32_MAX;

int disArr[501];

priority_queue> mypq;

vector> graph[10001];

vector trace[501];

int N, M, S, D, U, V, P;

void MyDijstra()
{  
    for (int i = 0; i <= N; i++) disArr[i] = INF;

    for (int i = 0; i < M; i++) {
        cin >> U >> V >> P;
        graph[U].push_back(make_pair(V, P));
    }

    // 우선순위 큐에 삽입.
    mypq.push({ 0, S }); // < first : 거리 , second : 노드 인덱스 >

    disArr[S] = 0;

    while (!mypq.empty()) {
        // -를 붙이는 이유는 우선순위 큐를 이용하여 정렬하기 위함이다.
        // (최소힙으로 구현)
        int ncost = -mypq.top().first;
        int now = mypq.top().second;

        mypq.pop();

        // 이미 담겨 있는 것보다 거리가 크면 넘어간다.
        if (disArr[now] < ncost) continue;

        // 해당 노드에서 연결된 모든 경로를 확인
        for (int i = 0; i < graph[now].size(); i++) {
            // dissum = 임시 노드 + 현재 노드에서 i로가는 비용
            int dissum = ncost + graph[now][i].second;
            // 비용이 더 작다면 최단경로 테이블 값을 갱신.
            // 같아도 확인이 필요하다.
            // 최소 거리가 여러개 있을 수 있기 떄문
            if (dissum <= disArr[graph[now][i].first]) {

                if (dissum < disArr[graph[now][i].first]) {
                
                    // 임시 노드 업데이트
                    disArr[graph[now][i].first] = dissum;

                    trace[graph[now][i].first].clear(); // 새로 갱신한다면 전에 있던 것이 필요가 없다.
                    trace[graph[now][i].first].push_back(now); // 경로를 저장

                    // 우선순위 큐에 (거리, 노드 인덱스) 푸시
                    mypq.push(make_pair(-dissum, graph[now][i].first));
                }
                else trace[graph[now][i].first].push_back(now); // 경로를 저장 역방향으로 넣어준다.
            }
        }
    }

    // 최단 거리의 경로를 삭제해 줍니다.
    queue delQ;
    delQ.push(D);
    while (!delQ.empty()) {
        int nowDel = delQ.front();
        delQ.pop();
        for (int i = 0; i < trace[nowDel].size(); i++) {
            for (auto it = graph[trace[nowDel][i]].begin(); it != graph[trace[nowDel][i]].end(); it++) {
                if ((*it).first == nowDel) {
                    delQ.push(trace[nowDel][i]);
                    graph[trace[nowDel][i]].erase(it);
                    break;
                }
            }
        }
    }


    // 새로운 데이크스트라를 진행하여 거의 최단 경로를 찾는다.
    for (int i = 0; i <= N; i++) disArr[i] = INF;
    // 우선순위 큐에 삽입.
    mypq.push({ 0, S }); // first : 거리 , second : 노드 인덱스
    disArr[S] = 0;
    while (!mypq.empty()) {
        // -를 붙이는 이유는 우선순위 큐를 이용하여 정렬하기 위함이다.
        // (최소힙으로 구현)
        int ncost = -mypq.top().first;
        int now = mypq.top().second;

        mypq.pop();

        // 이미 담겨 있는 것보다 거리가 크면 넘어간다.
        if (disArr[now] < ncost) continue;

        // 해당 노드에서 연결된 모든 경로를 확인
        for (int i = 0; i < graph[now].size(); i++) {
            // dissum = 임시 노드 + 현재 노드에서 i로가는 비용
            int dissum = ncost + graph[now][i].second;
            // 비용이 더 작다면 최단경로 테이블 값을 갱신.
            if (dissum < disArr[graph[now][i].first]) {

                disArr[graph[now][i].first] = dissum;
                // 우선순위 큐에 (거리, 노드 인덱스) 푸시
                mypq.push(make_pair(-dissum, graph[now][i].first));
            }
        }
    }

    for (int i = 0; i <= N; i++) trace[i].clear();
    for (int i = 0; i <= M; i++) graph[i].clear();
}


int main()
{
    ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
    //cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
    cin.tie(NULL);
    std::cout.tie(NULL);

    while (true) {

        cin >> N >> M;

        if (N == 0 && M == 0) break;

        cin >> S >> D;

        MyDijstra();

        if (disArr[D] == INF) cout << -1 << "\n";
        else cout << disArr[D] << "\n";
    }

    return 0;
}

틀린 코드를 포기할 수 없어 여러가지 방법으로 접근하여 메모리를 줄여보았지만 의미는 없었다.

The post 백준 5719번 (거의 최단 경로, C++, Dijkstra) / 추가 반례 [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

백준 10217번 (KCM Travel, C++, Dijkstra) [BAEKJOON]

lycos7560 — Fri, 03 Feb 2023 05:07:07 +0000

목차 테이블

KCM Travel

KCM Travel

https://www.acmicpc.net/problem/10217

시간 제한	메모리 제한	제출	정답	맞힌 사람	정답 비율
10 초	256 MB	21759	4834	2300	17.114%

문제

각고의 노력 끝에 찬민이는 2014 Google Code Jam World Finals에 진출하게 되었다.

구글에서 온 초대장을 받고 기뻐했던 것도 잠시, 찬찬히 읽어보던 찬민이는 중요한 사실을 알아차렸다.

최근의 대세에 힘입어 구글 역시 대기업답게 비용 감축에 열을 내고 있었던 것이다.

초대장 내용에 의하면 구글은 찬민에게 최대 M원까지의 비용만을 여행비로써 부담해주겠다고 한다.

인천에서 LA행 직항 한 번 끊어주는게 그렇게 힘드냐고 따지고도 싶었지만,

다가올 결승 대회를 생각하면 대회 외적인 곳에 마음을 쓰고 싶지 않은 것 또한 사실이었다.

그래서 찬민은 인천에서 LA까지 M원 이하로 사용하면서 도착할 수 있는 가장 빠른 길을 차선책으로 택하기로 하였다.

각 공항들간 티켓가격과 이동시간이 주어질 때,

찬민이 인천에서 LA로 갈 수 있는 가장 빠른 길을 찾아 찬민의 대회 참가를 도와주자.

입력

입력 파일의 첫 번째 줄에 테스트 케이스의 수를 의미하는 자연수 T가 주어진다.

그 다음에는 T개의 테스트 케이스가 주어진다.

각 테스트 케이스의 첫 줄에는 공항의 수 N (2 ≤ N ≤ 100), 총 지원비용 M (0 ≤ M ≤ 10,000),

티켓정보의 수 K (0 ≤ K ≤ 10,000)가 공백으로 구분되어 주어진다.

이어서 K개의 줄에 걸쳐 각 티켓의 출발공항 u, 도착공항 v (1 ≤ u, v ≤ N, u ≠ v), 비용 c (1 ≤ c ≤ M, 정수),

그리고 소요시간 d (1 ≤ d ≤ 1,000) 가 공백으로 구분되어 주어진다.

인천은 언제나 1번 도시이고, LA는 언제나 N번 도시이다

출력

각 테스트 케이스당 한 줄에 찬민이 LA에 도착하는 데 걸리는 가장 짧은 소요시간을 출력한다.

만약, LA에 도착할 수 없는 경우 “Poor KCM”을 출력한다.

예제 입력 1

예제 출력 1

2
Poor KCM

출처

Contest > Coder’s High > Coder ‘s High 2014 D번

데이터를 추가한 사람: doju, pichulia
문제의 오타를 찾은 사람: kjho1e3
문제를 만든 사람: tae

알고리즘 분류

해결 방법

백준 1162번 (도로포장, C++, Dijkstra) / 추가 반례 [BAEKJOON]

1162번 도로포장 문제와 유사한 방법으로 해결하였다.

통과된 코드 (재채점 이후 시간초과)

#include 
#include 
#include 
#include 

using namespace std;

priority_queue> myPQ;

long long int disArr[101][10001];

constexpr long long int INF = INT64_MAX;

int T, N, M, K, U, V, C, D, cnt;

long long int Dijstra()
{
    cin >> N >> M >> K;

    // 다익스트라 배열 초기화
    for (int i = 0; i <= N; i++)
        for (int j = 0; j <= M; j++)
            disArr[i][j] = INF;

    vector> graph[10000];

    for (int i = 0; i < K; i++) {
        cin >> U >> V >> C >> D;
        graph[U].push_back(make_tuple(V, C, D));
    }

    // 우선순위 큐에 삽입.
    myPQ.push({ 0, 1, 0 }); // <거리 , 노드 인덱스 , 비용>

    disArr[1][0] = 0;

    while (!myPQ.empty()) {
        // -를 붙이는 이유는 우선순위 큐를 이용하여 정렬하기 위함이다.
        // (최소힙으로 구현)
        long long int nCost = -get<0>(myPQ.top()); // 현재 최단 거리

        int now = get<1>(myPQ.top()); // 현재 노드

        int money = get<2>(myPQ.top()); // 비용 

        myPQ.pop();
        // 이미 담겨 있는 것보다 거리가 크면 넘어간다.
        if (disArr[now][money] < nCost) continue;
        // 해당 노드에서 연결된 모든 경로를 확인
        for (int i = 0; i < graph[now].size(); i++) {

            // 비용의 범위가 초과된다면 continue
            if (money + get<1>(graph[now][i]) > M) continue;

            // disSum = 임시 노드 + 현재 노드에서 i로가는 비용
            long long int disSum = nCost + get<2>(graph[now][i]);

            // 비용이 작다면 최단경로 테이블 값을 갱신.
            if (disSum < disArr[get<0>(graph[now][i])][money + get<1>(graph[now][i])]) {
                // 임시 노드 업데이트
                disArr[get<0>(graph[now][i])][money + get<1>(graph[now][i])] = disSum;
                // 우선순위 큐에 (거리, 노드 인덱스, 비용) 푸시
                myPQ.push({ -disSum, get<0>(graph[now][i]), money + get<1>(graph[now][i]) });

            }
        }
    }

    long long int result = INF;

    for (int i = 0; i <= M; i++) {
       result = min(disArr[N][i], result);
    }

    return result;
}


int main()
{
    ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
    // cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
    cin.tie(NULL);
    std::cout.tie(NULL);

    cin >> T;

    while (T-- > 0) {
        long long int result = Dijstra();
        if (result == INF) cout << "Poor KCM\n";
        else cout << result << "\n";
    }

    return 0;
}

재채점 이후

deque을 이용하여 해결

#include 
#include 
#include 
#include 
#define INF 987654321

using namespace std;

struct Info {
    int node;  // 도착 공항
    int cost;  // 티켓 비용
    int time;  // 소요 시간
};

int n, m, k;
vector> edges;
int dp[101][10001];  // dp[i][j]: i번 공항에 j 비용으로 도착했을 때 최소 소요 시간

void solve() {
    // 공항의 연결 정보 및 dp 배열 초기화
    edges.clear();
    edges.resize(n + 1);

    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= m; j++) {
            dp[i][j] = INF;
        }
    }

    // 티켓 정보 입력
    for (int i = 0; i < k; i++) {
        int u, v, c, d;
        cin >> u >> v >> c >> d;
        edges[u].push_back({ v, c, d });
    }

    // deque를 사용한 BFS 기반 탐색 (비용과 시간을 함께 고려)
    deque>> dq;  // {소요 시간, {공항, 비용}}
    dq.push_back({ 0, {1, 0} });  // 시작점: 1번 공항, 비용 0, 소요 시간 0
    dp[1][0] = 0;  // 1번 공항, 비용 0에서 시작

    while (!dq.empty()) {
        int time = dq.front().first;
        int here = dq.front().second.first;
        int cost = dq.front().second.second;
        dq.pop_front();

        // 이미 더 빠른 경로가 있는 경우 스킵
        if (dp[here][cost] < time) continue;

        // 현재 공항에서 갈 수 있는 다음 공항 탐색
        for (auto& next_info : edges[here]) {
            int next = next_info.node;
            int next_time = time + next_info.time;
            int next_cost = cost + next_info.cost;

            // 비용이 초과하면 무시
            if (next_cost > m) continue;

            // 다음 공항에 대한 비용-시간 정보가 더 최적이면 갱신
            if (next_time < dp[next][next_cost]) {
                dp[next][next_cost] = next_time;
                // deque에 삽입할 때, 비용이 더 낮은 경로를 우선으로 처리
                if (!dq.empty() && dq.front().first > next_time) {
                    dq.push_front({ next_time, {next, next_cost} });
                }
                else {
                    dq.push_back({ next_time, {next, next_cost} });
                }
            }
        }
    }

    int answer = INF;

    // 목적지 공항 n에 비용 m 이하로 도착하는 최소 소요 시간 탐색
    for (int i = 0; i <= m; i++) {
        answer = min(answer, dp[n][i]);
    }

    // 결과 출력: 도착할 수 없으면 "Poor KCM", 그렇지 않으면 최소 소요 시간 출력
    if (answer == INF) cout << "Poor KCM" << endl;
    else cout << answer << endl;
}

int main(void) {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    int t;
    cin >> t;  // 테스트 케이스 입력
    while (t--) {
        cin >> n >> m >> k;  // 공항 수, 최대 지원 비용, 티켓 정보 수 입력
        solve();
    }

    return 0;
}

The post 백준 10217번 (KCM Travel, C++, Dijkstra) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.