Algoritmo de Kruskal (minimo peso) c++

//Programa de Kruskal para encontrar el minimo

#include<bits/stdc++.h>
using namespace std;

//Creamos una estructura para representar el gráfico

struct Grafo
{
int V, E;
vector< pair<int, pair<int, int>> > edges;
Grafo(int V, int E)
{
this->V = V;
this->E = E;
}
//Función para añadir los valores
void AñadirBorde(int u, int w, int v)
{
edges.push_back({w, {u, v}});
}
int kruskalMST();
};

// representamos los conjuntos disjuntos

struct DisjointSets
{
int *parent, *rnk;
int n;

// Constructor.
DisjointSets(int n)
{
// Alojando en la memoria
this->n = n;
parent = new int[n+1];
rnk = new int[n+1];
for (int i = 0; i <= n; i++)
{
rnk[i] = 0;
parent[i] = i;
}
}
int find(int u)
{
if (u != parent[u])
parent[u] = find(parent[u]);
return parent[u];
}

// Unimos por rango

void merge(int x, int y)
{
x = find(x), y = find(y);
 if (rnk[x] > rnk[y])
parent[y] = x;
else // Si rnk[x] <= rnk[y]
parent[x] = y;

if (rnk[x] == rnk[y])
rnk[y]++;
}
};

/* Función que regresa el peso del grafo*/

int Grafo::kruskalMST()
{
int mst_wt = 0; // Inicializamos el resultado

// Ordenamos los bordes de manera creciente segun el costo

sort(edges.begin(), edges.end());

// Create disjoint sets

DisjointSets ds(V);

// Vamos iterando los bordes ordenados

vector< pair<int, pair<int, int>> >::iterator it;
for (it=edges.begin(); it!=edges.end(); it++)
{
int u = it->second.first;
int v = it->second.second;

int set_u = ds.find(u);

int set_v = ds.find(v);

if (set_u != set_v)
{
cout << u << " - " << v << endl;
mst_wt += it->first;
ds.merge(set_u, set_v);
}
}

return mst_wt;
}

int main()
{

int V = 9, E = 14;
Grafo g(V, E);

g.AñadirBorde(0, 5, 1);
g.AñadirBorde(0, 10, 3);
g.AñadirBorde(1, 2, 2);
g.AñadirBorde(1, 10, 5);
g.AñadirBorde(1, 5, 4);
g.AñadirBorde(2, 1, 3);
g.AñadirBorde(2, 5, 4);
g.AñadirBorde(2, 3, 0);
 g.AñadirBorde(4, 2, 5);

cout << "Los bordes del grafo son \n";

int mst_wt = g.kruskalMST();

cout << "\nEl peso menor del grafo es " << mst_wt;

return 0;
}

Algoritmo de dijkstra (java)

public class Dijkstra {

// Numero de vertices en el grafo

static final int V = 9;

// Funcion utilitaria para encontrar el vertice con la distancia minima,

// a partir del conjunto de los vertices todavia no incluidos en el

// camino mas corto

private static int minDistance(int[] dist, boolean[] verticeYaProcesado)

// Inicializando el valor minimo

int min = Integer.MAX_VALUE; int min_index=0;

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

 if (verticeYaProcesado[v] == false && dist[v] <= min) {

min = dist[v];

min_index = v;

return min_index;

// Funcion utilitaria para imprimir el arreglo de distancias calculadas

private static void printSolution(int[] dist, int n)

System.out.println("Distancia del vertice desde el origen\n");

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

System.out.println(i + " \t\t " + dist[i]);

private static void dijkstra(int[][] grafo, int src)

int[] dist = new int[V];

// dist[i] guarda la distancia mas corta desde src hasta el vertice

i

boolean[] verticeYaProcesado = new boolean[V];

//Este arreglo tiene true si el vertice i ya fue procesado

// Initialize all distances as INFINITE and stpSet[] as false

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

dist[i] = Integer.MAX_VALUE;

verticeYaProcesado[i] = false;

// La distancia del vertice origen hacia el mismo es siempre 0

dist[src] = 0;
 //Encuentra el camino mas corto para todos los vertices

for (int count = 0; count < V-1; count++)

//Toma el vertice con la distancia minima del cojunto de vertices

aun no procesados

//En la primera iteracion siempre se devuelve src

int u = minDistance(dist, verticeYaProcesado);

// Se marca como ya procesado

verticeYaProcesado[u] = true;

// Update dist value of the adjacent vertices of the picked

vertex.

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

//Se actualiza la dist[v] solo si no esta en verticeYaProcesado,

hay un

//arco desde u a v y el peso total del camino desde src hasta v

a traves de u es

// mas pequeno que el valor actual de dist[v]

if (!verticeYaProcesado[v] && grafo[u][v] > 0 && dist[u] !=

Integer.MAX_VALUE

&& dist[u]+grafo[u][v] < dist[v])

dist[v] = dist[u] + grafo[u][v];

// se imprime el arreglo con las distancias

printSolution(dist, V);

// driver program to test above function

public static void main(String[] args)

 {

/* Let us create the example graph discussed above */

int[][] graph = {{0, 4, 0, 0, 0, 0, 0, 8, 0},

{4, 0, 8, 0, 1, 0, 2, 11, 0},

{0, 8, 0, 7, 0, 4, 0, 0, 2},

{0, 1, 7, 0, 9, 14, 0, 0, 3},

{1, 0, 0, 9, 0, 10, 0, 8, 0},

{0, 0, 4, 9, 10, 0, 2, 0, 0},

{0, 0, 0, 14, 0, 2, 0, 1, 6},

{8, 11, 0, 0, 7, 0, 1, 0, 7},

{0, 0, 2, 0, 0, 0, 6, 7, 0}

};

dijkstra(graph, 0);

Algoritmo de Prim (java)

class Prim{

static class Grafo{

int vertices;

int mat[][];

public Grafo(int vertices){

this.vertices = vertices;

mat = new int[vertices][vertices];

public void addEdge(int ori, int des, int peso) {

mat[ori][des]=peso;

mat[des][ori]=peso;
 }

class Resultado {

int padre;

int peso;

int minVert( boolean [] mst, int [] pesos){

int minPeso = Integer.MAX_VALUE;

int vertice = -1;

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

if (mst[i]== false && minPeso > pesos [i]) {

minPeso =pesos [i];

vertice = i;

return vertice;

public void mst() {

boolean [] mst = new boolean[vertices];

int [] pesos = new int [vertices];

Resultado [] resultado = new Resultado [vertices];

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

pesos[i] = Integer.MAX_VALUE;

resultado[i] = new Resultado();

pesos[0]=0;

resultado[0].padre=-1;

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

int vertice = minVert(mst, pesos);

mst[vertice]= true;

for (int j = 0; j < vertices; j++) {

 if (mat[vertice][j]>0) {

if (mst[j]==false && mat[vertice][j]< pesos[j]) {

pesos[j] = mat[vertice][j];

resultado[j].padre=vertice;

resultado[j].peso = pesos[j];

printMst(resultado);

public void printMst( Resultado [] resultado ) {

int total_coste_min = 0;

System.out.println("Arbol de recubrimiento minimo");

for (int i = 1; i < vertices; i++) {

System.out.println("Arista " + i + " - " +

resultado[i].padre + " peso: " + resultado[i].peso);

total_coste_min +=resultado[i].peso;

System.out.println("Coste min total = " + total_coste_min);

public static void main(String[] args) {

int vertices = 6;

Grafo grafo = new Grafo(vertices);

grafo.addEdge(0, 1, 10);

grafo.addEdge(0, 2, 25);

grafo.addEdge(1, 4, 30);

grafo.addEdge(1, 2, 10);

grafo.addEdge(2, 5, 5);

grafo.addEdge(2, 3, 20);

grafo.addEdge(3, 5, 40);
grafo.addEdge(5, 4, 12);

grafo.mst();