1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;

namespace Grafo
{
public class cGrafo
{

#region *********************** ATRIBUTOS ************************

protected int aNroVertices;
protected object[] aVertices;
protected float [,] aMatrizAdyacencia;
#endregion *********************** ATRIBUTOS ************************

#region *********************** METODOS ************************

#region ==================== CONSTRUCTORES =======================
// ----------------------------------------------------------------
public cGrafo()
{
aNroVertices = 10;
aVertices = new object[aNroVertices];
aMatrizAdyacencia = new float[aNroVertices, aNroVertices];
}

// ----------------------------------------------------------------
public cGrafo(int pNroVertices)
{
aNroVertices = pNroVertices;
aVertices = new object[aNroVertices];
aMatrizAdyacencia = new float[aNroVertices, aNroVertices];
}
#endregion ==================== CONSTRUCTORES =======================

#region ==================== PROPIEDADES =======================

// ----------------------------------------------------------------
public int NroVertices
{
get { return aNroVertices; }
set { aNroVertices = value > 0? value : aNroVertices; }
}
#endregion ==================== PROPIEDADES =======================

#region ==================== MÉTODOS PROCESO =======================

// ----------------------------------------------------------------
public void InicializarMatrizAdyacencia()
{
// -- Redimensionar la matriz de adyacencia */
aMatrizAdyacencia = new float[aNroVertices, aNroVertices];
// -- Inicializar valores de la matriz de adyacencia
for (int F = 0; F < aNroVertices; F++)
for (int C = 0; C < aNroVertices; C++)
aMatrizAdyacencia[F, C] = float.NaN;
}

// ----------------------------------------------------------------
public void LeerDeArchivo(String Archivo)
{
// -- Abrir archivo
StreamReader SR = new StreamReader(Archivo);
// -- Leer Número de vertices
aNroVertices = int.Parse(SR.ReadLine());
// -- Inicializar la matriz de adyacencia */
InicializarMatrizAdyacencia();
// -- Leer relaciones entre vertices
for (int V = 0; V < aNroVertices; V++)
2

{
// -- Recuperar valores de la V-ésima fila
string[] Valores = SR.ReadLine().Split(',');
// -- Recuperar valor de cada elemento de la celda
for (int C = 0; C < aNroVertices; C++)
if (Valores[C] == "NaN")
aMatrizAdyacencia[V, C] = float.NaN;
else
aMatrizAdyacencia[V, C] = float.Parse(Valores[C]);
}
// -- Cerrar archivo
SR.Close();
}

// ----------------------------------------------------------------
public void Leer()
{
// -- Mostrar titulo
Console.WriteLine("INGRESAR DATOS DEL GRAFO");
// -- Nro de vertices */
Console.Write("Ingrese número de vértices: ");
aNroVertices = int.Parse(Console.ReadLine());
// -- Inicializar la matriz de adyacencia */
InicializarMatrizAdyacencia();
// -- Leer aristas
bool FlagMasAristas = true;
Console.WriteLine("INGRESAR ARISTAS");
do
{
// -- Leer datos de arista
Console.WriteLine();
Console.WriteLine("Ingrese datos de una arista: ");
Console.Write("Ingrese vértice Origen: ");
int VOrigen = int.Parse(Console.ReadLine());
Console.Write("Ingrese vértice Destino: ");
int VDestino = int.Parse(Console.ReadLine());
Console.Write("Ingrese valor de la arista: ");
float ValorArista = float.Parse(Console.ReadLine());
// -- Almacenar en la matriz de adyacencia
aMatrizAdyacencia[VOrigen, VDestino] = ValorArista;
aMatrizAdyacencia[VDestino, VOrigen] = ValorArista;
// -- Determinar si hay mas aristas
Console.WriteLine();
Console.Write("¿Hay más aristas? <S>: ");
string Rpta = Console.ReadLine();
FlagMasAristas = (Rpta == "s") || (Rpta == "S");
} while (FlagMasAristas);
}
// ----------------------------------------------------------------
public void Mostrar()
{
// Limpiar pantalla
Console.Clear();

// Mostrar Matriz de adycencia

Console.WriteLine("MATRIZ DE ADYACENCIA DEL GRAFO");
Console.WriteLine();

// -- Mostrar Vertices
for (int V = 0; V < aNroVertices; V++)
{
// -- Poner vertices al inicio de las columnas
Console.SetCursorPosition((V + 1) * 10, 1);
Console.WriteLine("V" + (V+1));
// -- Poner vertices al inicio de las filas
Console.SetCursorPosition(2, V + 2);
Console.WriteLine("V" + (V+1));
}
3

// -- Mostrar valor de las aristas

for (int F = 0; F < aNroVertices; F++)
{
for (int C = 0; C < aNroVertices; C++)
{
Console.SetCursorPosition((C + 1) * 10, F + 2);
Console.WriteLine(aMatrizAdyacencia[C, F]);
}
}

// ----------------------------------------------------------------
public void GrabarEnArchivo(String Archivo)
{
// -- Abrir archivo
StreamWriter SW = new StreamWriter(Archivo);
// -- Grabar Número de vertices
SW.WriteLine(aNroVertices.ToString());
// -- Grabar matriz de adyacencia
for (int V = 0; V < aNroVertices; V++)
{
// -- Generar texto con datos de cada fila
string TextoFila = "";
string Separador = "";
for (int C = 0; C < aNroVertices; C++)
{
if (float.IsNaN(aMatrizAdyacencia[V, C]))
TextoFila = Separador + "NaN";
else
TextoFila = Separador + aMatrizAdyacencia[V, C].ToString();
}
// -- Grabar texto fila
SW.WriteLine(TextoFila);
}
// -- Cerrar archivo
SW.Close();
}

//es conexo
public bool EsConexo()
{
// -- Crear vector de visitados
bool[] Visitados = new bool[aNroVertices];
// -- Inicializar vector de visitados
for (int V = 0; V < aNroVertices; V++)
Visitados[V] = false;
// -- Marcar el primer vertice como visitado
Visitados[0] = true;
// -- Crear cola de visitas
Queue<int> Cola = new Queue<int>();
// -- Encolar el primer vertice
Cola.Enqueue(0);
// -- Recorrer la cola
while (Cola.Count > 0)
{
// -- Desencolar un vertice
int V = Cola.Dequeue();
// -- Recorrer los vertices adyacentes
for (int C = 0; C < aNroVertices; C++)
{
// -- Si el vertice es adyacente y no ha sido visitado
if (!Visitados[C] && !float.IsNaN(aMatrizAdyacencia[V, C]))
{
// -- Marcar como visitado
Visitados[C] = true;
// -- Encolar el vertice
Cola.Enqueue(C);
}
4

}
}
// -- Verificar si todos los vertices han sido visitados
bool FlagConexo = true;
for (int V = 0; V < aNroVertices; V++)
if (!Visitados[V])
{
FlagConexo = false;
break;
}
// -- Retornar resultado
return FlagConexo;
}

#endregion ==================== MÉTODOS PROCESO =======================

#endregion *********************** METODOS ************************

}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Grafo;

namespace AppCaminosMInimoss
{
class Program
{
static void Main(string[] args)
{
// -- Crear objeto CaminosMInimos
cCaminosMinimos G = new cCaminosMinimos();
// -- Leer CaminosMInimos de archivo
G.LeerDeArchivo("Grafo02.csv");
// -- Ejecutar Dijkstra
G.Dijkstra();
// -- Mostrar cammino minimo y costo
G.MostrarCaminosMinimos();

//es conexo
if (G.EsConexo())
Console.WriteLine("El grafo es conexo");
else
Console.WriteLine("El grafo no es conexo");
// -- Pausa
Console.ReadKey();
}
}
}