ALGORITMO DIJKSTRA EN C++

#include <iostream>
#include <limits.h>
#include <float.h>
using namespace std;
#define MAXNODOS 500
// tamao mximo 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
vrtices 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
funcin 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 mnima
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 nmero 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 funcin
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). Adems dnde 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 ms corto que una
al vrtice i con el j tal que dicho camino no pase por un vrtice con nmero
mayor que k.
La matriz resultante es la de los mnimos 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 optimizacin.
//#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 expresin del ciclo interno establece que existe un camino i->j tal que NO
pasa por el vrtice con nmero mayor que k si:
Ya existe un camino i->j tal que no pasa por camino con nmero mayor que k-1

Existe un camino i -> k tal que no pasa por el vrtice con nmero mayor que
k-1 y si existe un camino k->j tal que no pasa por vrtice con nmero 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
Aadir(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 nmero total de vrtices
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.
// Ntese que el cluster contiene ms de un vrtice si una arista une
un par de
// vrtices que han sido aadidos 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;
}