Update

Author: ndb796

9/1.cpp

@@ -0,0 +1,80 @@
+#include <bits/stdc++.h>
+#define INF 1e9 // 무한을 의미하는 값으로 10억을 설정
+
+using namespace std;
+
+// 노드의 개수(N), 간선의 개수(M), 시작 노드 번호(Start)
+// 노드의 개수는 최대 100,000개라고 가정
+int n, m, start;
+// 각 노드에 연결되어 있는 노드에 대한 정보를 담는 배열
+vector<pair<int, int> > graph[100001];
+// 방문한 적이 있는지 체크하는 목적의 배열 만들기
+bool visited[100001];
+// 최단 거리 테이블 만들기
+int d[100001];
+
+// 방문하지 않은 노드 중에서, 가장 최단 거리가 짧은 노드의 번호를 반환
+int getSmallestNode() {
+    int min_value = INF;
+    int index = 0; // 가장 최단 거리가 짧은 노드(인덱스)
+    for (int i = 1; i <= n; i++) {
+        if (d[i] < min_value && !visited[i]) {
+            min_value = d[i];
+            index = i;
+        }
+    }
+    return index;
+}
+
+void dijkstra(int start) {
+    // 시작 노드에 대해서 초기화
+    d[start] = 0;
+    visited[start] = true;
+    for (int j = 0; j < graph[start].size(); j++) {
+        d[graph[start][j].first] = graph[start][j].second;
+    }
+    // 시작 노드를 제외한 전체 n - 1개의 노드에 대해 반복
+    for (int i = 0; i < n - 1; i++) {
+        // 현재 최단 거리가 가장 짧은 노드를 꺼내서, 방문 처리
+        int now = getSmallestNode();
+        visited[now] = true;
+        // 현재 노드와 연결된 다른 노드를 확인
+        for (int j = 0; j < graph[now].size(); j++) {
+            int cost = d[now] + graph[now][j].second;
+            // 현재 노드를 거쳐서 다른 노드로 이동하는 거리가 더 짧은 경우
+            if (cost < d[graph[now][j].first]) {
+                d[graph[now][j].first] = cost;
+            }
+        }
+    }
+}
+
+int main(void) {
+    cin >> n >> m >> start;
+
+    // 모든 간선 정보를 입력받기
+    for (int i = 0; i < m; i++) {
+        int a, b, c;
+        cin >> a >> b >> c;
+        // a번 노드에서 b번 노드로 가는 비용이 c라는 의미
+        graph[a].push_back({b, c});
+    }
+
+    // 최단 거리 테이블을 모두 무한으로 초기화
+    fill_n(d, 100001, INF);
+    
+    // 다익스트라 알고리즘을 수행
+    dijkstra(start);
+
+    // 모든 노드로 가기 위한 최단 거리를 출력
+    for (int i = 1; i <= n; i++) {
+        // 도달할 수 없는 경우, 무한(INFINITY)이라고 출력
+        if (d[i] == INF) {
+            cout << "INFINITY" << '\n';
+        }
+        // 도달할 수 있는 경우 거리를 출력
+        else {
+            cout << d[i] << '\n';
+        }
+    }
+}

9/2.cpp

@@ -0,0 +1,66 @@
+#include <bits/stdc++.h>
+#define INF 1e9 // 무한을 의미하는 값으로 10억을 설정
+
+using namespace std;
+
+// 노드의 개수(N), 간선의 개수(M), 시작 노드 번호(Start)
+// 노드의 개수는 최대 100,000개라고 가정
+int n, m, start;
+// 각 노드에 연결되어 있는 노드에 대한 정보를 담는 배열
+vector<pair<int, int> > graph[100001];
+// 최단 거리 테이블 만들기
+int d[100001];
+
+void dijkstra(int start) {
+    priority_queue<pair<int, int> > pq;
+    // 시작 노드로 가기 위한 최단 경로는 0으로 설정하여, 큐에 삽입
+    pq.push({0, start});
+    d[start] = 0;
+    while (!pq.empty()) { // 큐가 비어있지 않다면
+        // 가장 최단 거리가 짧은 노드에 대한 정보 꺼내기
+        int dist = -pq.top().first; // 현재 노드까지의 비용 
+        int now = pq.top().second; // 현재 노드
+        pq.pop();
+        // 현재 노드가 이미 처리된 적이 있는 노드라면 무시
+        if (d[now] < dist) continue;
+        // 현재 노드와 연결된 다른 인접한 노드들을 확인
+        for (int i = 0; i < graph[now].size(); i++) {
+            int cost = dist + graph[now][i].second;
+            // 현재 노드를 거쳐서, 다른 노드로 이동하는 거리가 더 짧은 경우
+            if (cost < d[graph[now][i].first]) {
+                d[graph[now][i].first] = cost;
+                pq.push(make_pair(-cost, graph[now][i].first));
+            }
+        }
+    }
+}
+
+int main(void) {
+    cin >> n >> m >> start;
+
+    // 모든 간선 정보를 입력받기
+    for (int i = 0; i < m; i++) {
+        int a, b, c;
+        cin >> a >> b >> c;
+        // a번 노드에서 b번 노드로 가는 비용이 c라는 의미
+        graph[a].push_back({b, c});
+    }
+
+    // 최단 거리 테이블을 모두 무한으로 초기화
+    fill(d, d + 100001, INF);
+    
+    // 다익스트라 알고리즘을 수행
+    dijkstra(start);
+
+    // 모든 노드로 가기 위한 최단 거리를 출력
+    for (int i = 1; i <= n; i++) {
+        // 도달할 수 없는 경우, 무한(INFINITY)이라고 출력
+        if (d[i] == INF) {
+            cout << "INFINITY" << '\n';
+        }
+        // 도달할 수 있는 경우 거리를 출력
+        else {
+            cout << d[i] << '\n';
+        }
+    }
+}

9/3.cpp

@@ -0,0 +1,58 @@
+#include <bits/stdc++.h>
+#define INF 1e9 // 무한을 의미하는 값으로 10억을 설정
+
+using namespace std;
+
+// 노드의 개수(N), 간선의 개수(M)
+// 노드의 개수는 최대 500개라고 가정
+int n, m;
+// 2차원 배열(그래프 표현)를 만들기
+int graph[501][501];
+
+int main(void) {
+    cin >> n >> m;
+
+    // 최단 거리 테이블을 모두 무한으로 초기화
+    for (int i = 0; i < 501; i++) {
+        fill(graph[i], graph[i] + 501, INF);
+    }
+
+    // 자기 자신에서 자기 자신으로 가는 비용은 0으로 초기화
+    for (int a = 1; a <= n; a++) {
+        for (int b = 1; b <= n; b++) {
+            if (a == b) graph[a][b] = 0;
+        }
+    }
+
+    // 각 간선에 대한 정보를 입력 받아, 그 값으로 초기화
+    for (int i = 0; i < m; i++) {
+        // A에서 B로 가는 비용은 C라고 설정
+        int a, b, c;
+        cin >> a >> b >> c;
+        graph[a][b] = c;
+    }
+    
+    // 점화식에 따라 플로이드 워셜 알고리즘을 수행
+    for (int k = 1; k <= n; k++) {
+        for (int a = 1; a <= n; a++) {
+            for (int b = 1; b <= n; b++) {
+                graph[a][b] = min(graph[a][b], graph[a][k] + graph[k][b]);
+            }
+        }
+    }
+
+    // 수행된 결과를 출력
+    for (int a = 1; a <= n; a++) {
+        for (int b = 1; b <= n; b++) {
+            // 도달할 수 없는 경우, 무한(INFINITY)이라고 출력
+            if (graph[a][b] == INF) {
+                cout << "INFINITY" << ' ';
+            }
+            // 도달할 수 있는 경우 거리를 출력
+            else {
+                cout << graph[a][b] << ' ';
+            }
+        }
+        cout << '\n';
+    }
+}

9/4.cpp

@@ -0,0 +1,59 @@
+#include <bits/stdc++.h>
+#define INF 1e9 // 무한을 의미하는 값으로 10억을 설정
+
+using namespace std;
+
+// 노드의 개수(N), 간선의 개수(M)
+int n, m;
+// 2차원 배열(그래프 표현)를 만들기
+int graph[101][101];
+
+int main(void) {
+    cin >> n >> m;
+
+    // 최단 거리 테이블을 모두 무한으로 초기화
+    for (int i = 0; i < 101; i++) {
+        fill(graph[i], graph[i] + 101, INF);
+    }
+
+    // 자기 자신에서 자기 자신으로 가는 비용은 0으로 초기화
+    for (int a = 1; a <= n; a++) {
+        for (int b = 1; b <= n; b++) {
+            if (a == b) graph[a][b] = 0;
+        }
+    }
+
+    // 각 간선에 대한 정보를 입력 받아, 그 값으로 초기화
+    for (int i = 0; i < m; i++) {
+        // A와 B가 서로에게 가는 비용은 1이라고 설정
+        int a, b;
+        cin >> a >> b;
+        graph[a][b] = 1;
+        graph[b][a] = 1;
+    }
+
+    // 거쳐 갈 노드 X와 최종 목적지 노드 K를 입력받기
+    int x, k;
+    cin >> x >> k;
+
+    // 점화식에 따라 플로이드 워셜 알고리즘을 수행
+    for (int k = 1; k <= n; k++) {
+        for (int a = 1; a <= n; a++) {
+            for (int b = 1; b <= n; b++) {
+                graph[a][b] = min(graph[a][b], graph[a][k] + graph[k][b]);
+            }
+        }
+    }
+
+    // 수행된 결과를 출력
+    int distance = graph[1][k] + graph[k][x];
+
+    // 도달할 수 없는 경우, -1을 출력
+    if (distance >= INF) {
+        cout << "-1" << '\n';
+    }
+    // 도달할 수 있다면, 최단 거리를 출력
+    else {
+        cout << distance << '\n';
+    }
+}

9/5.cpp

@@ -0,0 +1,68 @@
+#include <bits/stdc++.h>
+#define INF 1e9 // 무한을 의미하는 값으로 10억을 설정
+
+using namespace std;
+
+// 노드의 개수(N), 간선의 개수(M), 시작 노드 번호(Start)
+int n, m, start;
+// 각 노드에 연결되어 있는 노드에 대한 정보를 담는 배열
+vector<pair<int, int> > graph[30001];
+// 최단 거리 테이블 만들기
+int d[30001];
+
+void dijkstra(int start) {
+    priority_queue<pair<int, int> > pq;
+    // 시작 노드로 가기 위한 최단 경로는 0으로 설정하여, 큐에 삽입
+    pq.push({0, start});
+    d[start] = 0;
+    while (!pq.empty()) { // 큐가 비어있지 않다면
+        // 가장 최단 거리가 짧은 노드에 대한 정보 꺼내기
+        int dist = -pq.top().first; // 현재 노드까지의 비용 
+        int now = pq.top().second; // 현재 노드
+        pq.pop();
+        // 현재 노드가 이미 처리된 적이 있는 노드라면 무시
+        if (d[now] < dist) continue;
+        // 현재 노드와 연결된 다른 인접한 노드들을 확인
+        for (int i = 0; i < graph[now].size(); i++) {
+            int cost = dist + graph[now][i].second;
+            // 현재 노드를 거쳐서, 다른 노드로 이동하는 거리가 더 짧은 경우
+            if (cost < d[graph[now][i].first]) {
+                d[graph[now][i].first] = cost;
+                pq.push(make_pair(-cost, graph[now][i].first));
+            }
+        }
+    }
+}
+
+int main(void) {
+    cin >> n >> m >> start;
+
+    // 모든 간선 정보를 입력받기
+    for (int i = 0; i < m; i++) {
+        int x, y, z;
+        cin >> x >> y >> z;
+        // X번 노드에서 Y번 노드로 가는 비용이 Z라는 의미
+        graph[x].push_back({y, z});
+    }
+
+    // 최단 거리 테이블을 모두 무한으로 초기화
+    fill(d, d + 30001, INF);
+    
+    // 다익스트라 알고리즘을 수행
+    dijkstra(start);
+
+    // 도달할 수 있는 노드의 개수
+    int count = 0;
+    // 도달할 수 있는 노드 중에서, 가장 멀리 있는 노드와의 최단 거리
+    int maxDistance = 0;
+    for (int i = 1; i <= n; i++) {
+        // 도달할 수 있는 노드인 경우
+        if (d[i] != INF) {
+            count += 1;
+            maxDistance = max(maxDistance, d[i]);
+        }
+    }
+
+    // 시작 노드는 제외해야 하므로 count - 1을 출력
+    cout << count - 1 << ' ' << maxDistance << '\n';
+}