#include <iostream>

#include <vector>

#include <algorithm>

#include <queue>

#include <unordered_map>

#include <unordered_set>

using namespace std;

class GraphKruskal {

public:

int V;

vector<vector<int>> edges;

GraphKruskal(int vertices) : V(vertices) {}

void addEdge(int u, int v, int w) {

edges.push_back({u, v, w});

int find(vector<int>& parent, int i) {

if (parent[i] == i)

return i;

return find(parent, parent[i]);

void unionSets(vector<int>& parent, vector<int>& rank, int x, int y) {

int xRoot = find(parent, x);

int yRoot = find(parent, y);

 if (rank[xRoot] < rank[yRoot])

parent[xRoot] = yRoot;

else if (rank[xRoot] > rank[yRoot])

parent[yRoot] = xRoot;

else {

parent[yRoot] = xRoot;

rank[xRoot]++;

vector<vector<int>> kruskal() {

vector<vector<int>> result;

sort(edges.begin(), edges.end(), [](const vector<int>& a, const vector<int>& b) {

return a[2] < b[2];

});

vector<int> parent(V);

vector<int> rank(V, 0);

for (int i = 0; i < V; ++i)

parent[i] = i;

int i = 0, e = 0;

while (e < V - 1 && i < edges.size()) {

int u = edges[i][0], v = edges[i][1], w = edges[i][2];

++i;

int x = find(parent, u);

int y = find(parent, v);

 if (x != y) {

result.push_back({u, v, w});

unionSets(parent, rank, x, y);

++e;

return result;

};

class GraphDijkstra {

public:

unordered_map<char, vector<pair<char, int>>> graph;

void addEdge(char u, char v, int w) {

graph[u].push_back({v, w});

graph[v].push_back({u, w});

unordered_set<char> dijkstra(char start) {

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

unordered_set<char> visited;

pq.push({0, start});

while (!pq.empty()) {

pair<int, char> current = pq.top();

 pq.pop();

char currentVertex = current.second;

int currentDistance = current.first;

if (visited.count(currentVertex))

continue;

visited.insert(currentVertex);

for (const auto& neighbor : graph[currentVertex]) {

char nextVertex = neighbor.first;

int weight = neighbor.second;

if (!visited.count(nextVertex))

pq.push({currentDistance + weight, nextVertex});

return visited;

};

int main() {

int numVertices, numEdges;

cout << "Masukkan jumlah vertex: ";

cin >> numVertices;

GraphKruskal gKruskal(numVertices);
cout << "Masukkan jumlah edge: ";

cin >> numEdges;

cout << "Masukkan edge (format: u v w):" << endl;

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

int u, v, w;

cin >> u >> v >> w;

gKruskal.addEdge(u, v, w);

cout << "\nMinimum Spanning Tree (Kruskal):" << endl;

auto kruskalResult = gKruskal.kruskal();

for (const auto& edge : kruskalResult) {

cout << edge[0] << " - " << edge[1] << " : " << edge[2] << endl;

GraphDijkstra gDijkstra;

cout << "\nMasukkan jumlah edge untuk Dijkstra: ";

cin >> numEdges;

cout << "Masukkan edge untuk Dijkstra (format: u v w):" << endl;

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

char u, v;

int w;

cin >> u >> v >> w;

gDijkstra.addEdge(u, v, w);

}
 char startVertex;

cout << "\nMasukkan vertex awal untuk Dijkstra: ";

cin >> startVertex;

cout << "\nDijkstra Shortest Path:" << endl;

auto dijkstraResult = gDijkstra.dijkstra(startVertex);

for (const auto& vertex : dijkstraResult) {

cout << vertex << " ";

return 0;