ALGORITMO DIJKSTRA EN C++

#include <iostream>
#include <limits.h>
#include <float.h>
using namespace std;
#define MAXNODOS 500 // tamaño máximo de la red
#define INDEFINIDO -1
int N;
float dist[MAXNODOS][MAXNODOS];
float minimo[MAXNODOS];
int anterior[MAXNODOS];
bool visitado[MAXNODOS];
bool minimoNodoNoVisitado (int * nodo)
{
int candidato = -1;
for (int n = 0; n < N; n++) {
if (!visitado[n] && (minimo[n] < minimo[candidato] ||
candidato == -1)) {
candidato = n;
}
}
*nodo = candidato;
return candidato != -1;
}
void dijkstra (int origen, int destino) {

minimo[origen] = 0.0;
int nodo;
while (minimoNodoNoVisitado(&nodo)) {
if (minimo[nodo] == FLT_MAX)
return; // otros
vértices son inaccesibles
visitado[nodo] = true;
for (int n = 0; n < N; n++) {
if (!visitado[n] && distancia[nodo][n] < 1.0) {
float posibleMin = minimo[nodo] +
distancia[nodo][n];
if (posibleMin < minimo[n]) {
minimo[n] = posibleMin;
anterior[n] = nodo;
}}}}}
void camino_minimo (int inicio, int final)
{
if (inicio != final) {
camino_minimo (inicio, anterior[final]);
cout << ", ";
}
cout << final;
}
int main(int argc, char **argv)
{
int M, inicio, final;
// inicializar matriz de distancias y camino minimo
cin >> N;
for (int k = 0; k < N; k++) {
anterior[k] = INDEFINIDO;
visitado[k] = false;
minimo[k] = MAXINT;
for (int l = 0; l < N; l++) {
camino[k][l] = FLT_MAX;
}
}
// leer distancias en arcos reales
cin >> M;
for (int k = 0; k < M; k++) {
int i, j;
cin >> i >> j;
cin >> prob[i][j];
}
cin >> inicio >> final;
dijkstra(inicio, final);
camino_minimo(inicio, final);
return 0;
}
EN PSEUDOCODIGO
función Dijkstra (Grafo G, nodo_salida s)
//Usaremos un vector para guardar las distancias del nodo salida al resto
entero distancia[n] //Inicializamos el vector con distancias iniciales
booleano visto[n] //vector de boleanos para controlar los vertices de los
que ya tenemos la distancia mínima
para cada w ∈ V[G] hacer
Si (no existe arista entre s y w) entonces
distancia[w] = Infinito //puedes marcar la casilla con un -1 por
ejemplo
Si_no
distancia[w] = peso (s, w)
fin si
fin para
distancia[s] = 0
visto[s] = cierto
//n es el número de vertices que tiene el Grafo
mientras que (no_esten_vistos_todos) hacer
vertice = coger_el_minimo_del_vector distancia y que no este visto;
visto[vertice] = cierto;
para cada w ∈ sucesores (G, vertice) hacer
si distancia[w]>distancia[vertice]+peso (vertice, w) entonces
distancia[w] = distancia[vertice]+peso (vertice, w)
fin si
fin para
fin mientras
fin función
ALGORITMO DE FLOYD
Inicio
Armar la matriz de adyacencia F, teniendo en cuenta que F(i,j)=0 si i = j
(diagonal principal es 0). Además dónde no exista camino se debe indicar con
infinito.
Para k desde 1 hasta n
Para i desde 1 hasta n
Para j desde 1 hasta n
F[i,j]=min(F[i,j], F[i,k] + F[k,j])
Fin para j
Fin para i
Fin para k
En la k-esima  vuelta F[i, j] contendrá el valor del camino más corto que una
al vértice i con el j tal que dicho camino no pase por un vértice con número
mayor que k.
La matriz resultante es la de los mínimos caminos entre cada nodo. Si se
quiere saber cual es dicho camino, se debe armar un árbol a medida tomando
como numero de nodo a k cada vez que se detecta que hubo una optimización.

//#include <fstream.h>
#include <iostream.h>
#include <conio.h>
#define INF 999
#define N 3
void mostrar(int [N][N]);
void main()
{
int k,i,j;
int F[N][N]={ 0, 8, 5,3, 0,INF,INF, 2, 0 };
clrscr();
cout << "k = 0" << endl;
mostrar(F);
for(k=0;k<N;k++)
{
for(i=0;i<N;i++)
{
for(j=0;j<N;j++)
{
if(i!=j){
cout << "Fk [" << (i+1) << ", " << (j+1) << "] = min(Fk-1[";
cout << (i+1) << ", " << (j+1) << "], Fk-1[";
cout << (i+1) << ", " << (k+1) << "] + Fk-1[";
cout << (k+1) << ", " << (j+1) << "])" << endl;
cout << " " << F[i][j];
cout << " " << F[i][k] + F[k][j];
if(F[i][j] > F[i][k] + F[k][j])
{
F[i][j] = F[i][k] + F[k][j];
cout << " =>Fk [" << (i+1) << ", ";
cout << (j+1) << "] = " << F[i][j]; }
cout << endl;}}}
cout << "k = " << (k+1) << endl;
mostrar(F);}
}
void mostrar(int F[N][N])
{
int i,j;
for(i=0;i<N;i++)
{
for(j=0;j<N;j++)
{
cout << F[i][j] << "\t";
}
cout << endl;}}

ALGORITMO DE WARSHALL
Inicio
W(i,j)=0 si i = j (diagonal principal es 0).
Para k desde 1 hasta n
Para i desde 1 hasta n
Para j desde 1 hasta n
SI (i!=j)     W[i,j]=W[i,j] OR W[i,k] AND W[k,j]
Fin para j
Fin para i
Fin para k
La matriz resultante es la que indica si es posible un camino sin importar su
longitud.
La expresión del ciclo interno establece que existe un camino i->j tal que NO
pasa por el vértice con número mayor que k si:
Ya existe un camino i->j tal que no pasa por camino con “número” mayor que k-1
Ó
Existe un camino i -> k tal que no pasa por el vértice con “número” mayor que
k-1 y si existe un camino k->j tal que no pasa por vértice con número mayor
que k-1

#include<iostream.h>
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
class path
{
int n;
int p[10][10];
int a[10][10];
int c[10][10];
public:
void get();
void pm();
void ap();
void disp();
};
void path::get()
{ int i,j,k;
clrscr();
cout<<"Enter the no. of nodes in the graph :";
cin>>n;
cout<<"Enter the adjacency matrix :";
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{// cout<<"a["<<i<<","<<j<<"] = ";
cin>>a[i][j];
p[i][j]=0;
}}
cout<<"Enter The cost matrix is :";
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{// cout<<"a["<<i<<","<<j<<"] = ";
cin>>c[i][j];
}}
for(i=1;i<=n;i++)
{for(j=1;j<=n;j++)
 {p[i][j]=a[i][j];
}}}
void path::disp()
{
//cout<<"The output matrix for the given graph is :";
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
cout<<p[i][j]<< " ";
}cout<<endl;}}
void path::pm()
{int i,j,k;
for(k=1;k<=n;k++)
{
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
p[i][j]=p[i][j] || p[i][k] && p[k][j];
}}}}
void path::ap()
{
int i,j,k;
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
p[i][j]=c[i][j];
}}
for(k=1;k<=n;k++)
{
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++){
if(p[i][j]<p[i][k]+p[k][j])
{p[i][j]=p[i][j];}
else{
p[i][j]=p[i][k]+p[k][j];}}}}}
void main()
{
path p;
p.get();
p.pm();
cout<<"path matrix is :";
p.disp();
getch();
p.ap();
cout<<"all pair shortest path matrix is :";
p.disp();
getch();}

ALGORITMO DE PRIM
JARNIK (Grafo G, nodo_fuente s)
// Inicializamos todos los nodos del grafo. La distancia la ponemos a infinito
y el padre de cada nodo a NULL
// Encolamos, en una cola de prioridad donde la prioridad es la distancia,
todas las parejas <nodo,distancia> del grafo
por cada u en V[G] hacer
distancia[u] = INFINITO
padre[u] = NULL
Añadir(cola,<u,distancia[u]>)
distancia[s]=0
mientras cola != 0 do
// OJO: Se entiende por mayor prioridad aquel nodo cuya
distancia[u] es menor.
u = extraer_minimo(cola) //devuelve el minimo y lo elimina de la
cola.
por cada v adyacente a 'u' hacer
si ((v ∈ cola) && (distancia[v] > peso(u, v)) entonces
padre[v] = u
distancia[v] = peso(u, v)
Actualizar(cola,<v,distancia[v]>)
ALGORITMO DE KRUSKAL
function Kruskal(G)
for each vertex v in G do
Define an elementary cluster C(v) ← {v}.
Initialize a priority queue Q to contain all edges in G, using the
weights as keys.
Define a tree T ← Ø //T will ultimately contain the edges of the
MST
// n es el número total de vértices
while T has fewer than n-1 edges do
// edge u, v is the minimum weighted route from/to v
(u,v) ← Q.removeMin()
// previene ciclos en T. suma u, v solo si T no contiene una arista
que una u y v.
// Nótese que el cluster contiene más de un vértice si una arista une
un par de
// vértices que han sido añadidos al árbol.
Let C(v) be the cluster containing v, and let C(u) be the cluster
containing u.
if C(v) ≠ C(u) then
Add edge (v,u) to T.
Merge C(v) and C(u) into one cluster, that is, union C(v) and C(u).
return tree T

#include<iostream>
#include<vector>
#include<algorithm>
#define max 100
using namespace std;
struct Edge{
int vi,vj,w;
};
bool lequal(Edge const* t1, Edge const* t2){
return (t1->w<t2->w);}
int V,E;
vector <Edge*>edges;
vector <Edge*>mst;
int cicles[max];
int main(){
int i,W,number,c;
Edge *e;
c=1;
while(true){
edges.clear();
mst.clear();
cin>>V>>E;
if(!V && !E) break;
for(i=0;i<E;i++){
e = new Edge;
cin>>e->vi>>e->vj>>e->w;
edges.push_back(e);
}
sort(edges.begin(),edges.end(),lequal);
for(i=0;i<V;i++) cicles[i] = i;
while(mst.size()<(V-1) && edges.size()){
if(cicles[edges[0]->vi]!=cicles[edges[0]->vj]){
number = cicles[edges[0]->vj];
for(i=0;i<V;i++) {
if(cicles[i]==number)
cicles[i] = cicles[edges[0]->vi];}
mst.push_back(edges[0]); }
edges.erase(edges.begin(),edges.begin()+1); }
W = 0;
for(i=0;i<mst.size();i++) {
W+=mst[i]->w;
}
cout<<"Case "<<c++<<":"<<endl;
cout<<"The Minimun Spanning Tree has cost: "<<W<<endl;
}

return 0;
}