コード例 #1
0
ファイル: Form1.cs プロジェクト: sancas/ProgramacionIV
        private Vertice ventanaVertice; // ventana para agregar los vértices

        #endregion Fields

        #region Constructors

        public Simulador()
        {
            InitializeComponent();
            this.StyleManager = SimuladorStyleManager;
            grafo = new CGrafo();
            nuevoNodo = null;
            var_control = 0;
            ventanaVertice = new Vertice();
            ventanaArco = new Arco();
            ventanaBuscarNodo = new BuscarNodo();

            this.SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint | ControlStyles.DoubleBuffer, true);
        }
コード例 #2
0
        public static G.Grafo inicializaAresta(G.Grafo g, int id)
        {
            List <G.ViewModel.ArestaViewModel> avm = SelecionarArestas(id);

            foreach (var item in avm)
            {
                G.Vertice v1   = g.Vertices.FirstOrDefault(c => c.ID == item.v1);
                G.Vertice v2   = g.Vertices.FirstOrDefault(c => c.ID == item.v2);
                int       peso = item.peso;
                g.Vertices.FirstOrDefault(c => c.ID == item.v1).Arestas.Add(new G.Aresta(v1, v2, peso));
            }
            return(g);
        }
コード例 #3
0
        //Crea una arista entre dos vertices dados
        public void AgregarConexion(Vertice verticeInicial, Vertice verticeFinal, int peso)
        {
            //se crea una nueva arista con los parametros del metodo
            var arista = new Arista(peso, verticeInicial, verticeFinal);

            //Al vertice inicial y final se le avisan sus aristas
            verticeInicial.Aristas.Add(arista);
            verticeFinal.Aristas.Add(arista);

            //Se agregan los vertices y aristas a la lista del grafo para que sepa cuales tiene, se usa ExisteVertice que retorna un bool
            if (!ExisteVertice(verticeInicial))
            {
                VerticesL.Add(verticeInicial);
            }
            if (!ExisteVertice(verticeFinal))
            {
                VerticesL.Add(verticeFinal);
            }
            AristasL.Add(arista);
        }
コード例 #4
0
        private bool ExisteCamino(Vertice A, Vertice B, Estados Estados)
        {
            if (A == B)
            {
                return(true);
            }
            Estados[A.Nombre] = true;

            foreach (var val in A.Aristas)
            {
                if (!Estados[val.Fin.Nombre])
                {
                    if (ExisteCamino(val.Fin, B, Estados))
                    {
                        return(true);
                    }
                }
            }

            return(false);
        }
コード例 #5
0
        public void BFS(Vertice <T> origen)
        {
            this.visitar(origen);             //Visito U
            Cola <Vertice <T> > cola = new Cola <Vertice <T> >();

            cola.encolar(origen);            //Encolo U
            while (!cola.esVacia())
            {
                Vertice <T> vertice = cola.desencolar();             //Desencolo U
                Console.Write(vertice.getDato() + " ");              //Muestro el dato de U
                if (vertice.getAdyacentes().Count != 0)              //Verifico que tenga vecinos
                {
                    List <Arista <T> > vecinos = vertice.getAdyacentes();
                    foreach (Arista <T> arista in vecinos)
                    {
                        if (!this.visitar(arista.getDestino()))
                        {
                            cola.encolar(arista.getDestino());                             //Encolos los vecinos de U que no fueron visitados
                        }
                    }
                }
            }
        }
コード例 #6
0
 public void set_vertice_caminho_anterior(Vertice v)
 {
     _vertice_anterior = v;
 }
コード例 #7
0
 public int get_peso(Vertice v)
 {
     return(adjacencias[v]);
 }
コード例 #8
0
 public void inserir_vertice_adjacente(Vertice para, int peso)
 {
     adjacencias[para] = peso;
 }
コード例 #9
0
        static void Main(string[] args)
        {
            int[,] MatrizAdjacencia;
            int count = 0;

            Console.ForegroundColor = ConsoleColor.Red;
            List <Vertice> _verticesGrafo = new List <Vertice>();
            List <string>  _TodasArestas  = new List <string>();

            string[] lines = System.IO.File.ReadAllLines("Arquivo.txt");
            foreach (string line in lines)
            {
                _TodasArestas.Add(line.ToArray()[3].ToString());
                if (_verticesGrafo.Where(x => x.Nome == line.ToArray()[0].ToString()).FirstOrDefault() == null)
                {
                    Vertice novo = new Vertice(line.ToArray()[0].ToString());
                    _verticesGrafo.Add(novo);
                }
                if (_verticesGrafo.Where(x => x.Nome == line.ToArray()[5].ToString()).FirstOrDefault() == null)
                {
                    _verticesGrafo.Add(new Vertice(line.ToArray()[5].ToString()));
                }
                count++;
            }

            MatrizAdjacencia = new int[count, count];


            Console.WriteLine("TODOS OS VÉRTICES DO GRAFO!");
            foreach (Vertice obj in _verticesGrafo)
            {
                Console.WriteLine(obj.Nome);
            }

            foreach (string line in lines)
            {
                Vertice no  = _verticesGrafo.Where(x => x.Nome == line.ToArray()[0].ToString()).FirstOrDefault();
                Vertice no2 = _verticesGrafo.Where(x => x.Nome == line.ToArray()[5].ToString()).FirstOrDefault();
                if (no.Arestas.Where(y => y.No1.Nome == no.Nome && y.No2.Nome == no2.Nome).FirstOrDefault() == null)
                {
                    no.ConectarArestas(no2, line.ToArray()[3].ToString(), Convert.ToInt32(line.ToArray()[3].ToString()));
                }
                else if (no2.Arestas.Where(y => y.No1.Nome == no.Nome && y.No2.Nome == no2.Nome).FirstOrDefault() == null)
                {
                    no2.ConectarArestas(no, line.ToArray()[3].ToString(), Convert.ToInt32(line.ToArray()[3].ToString()));
                }
            }
            //------------------------------------------------------------------------------------
            // MATRIZ DE ADJACENCIA
            //------------------------------------------------------------------------------------
            Console.WriteLine("\n\tMATRIZ DE ADJACÊNCIA");
            foreach (Vertice obj in _verticesGrafo)
            {
                Console.Write("\t" + obj.Nome);
            }
            Console.WriteLine("\n");

            int i = 0, j = 0;

            foreach (Vertice obj in _verticesGrafo)
            {
                Console.Write(obj.Nome);
                foreach (Vertice second in _verticesGrafo)
                {
                    Aresta aux = obj.Arestas.Where(x => x.No1.Nome == second.Nome || x.No2.Nome == second.Nome).FirstOrDefault();
                    if (aux != null && obj.Nome != second.Nome)
                    {
                        MatrizAdjacencia[i, j] = aux.Peso;
                        Console.Write("\t1");
                    }
                    else
                    {
                        MatrizAdjacencia[i, j] = 0;
                        Console.Write("\t0");
                    }
                    aux = null;
                    j++;
                }
                i++;
                j = 0;
                Console.WriteLine("\n");
            }

            //------------------------------------------------------------------------------------
            // MATRIZ DE INCIDÊNCIA
            //------------------------------------------------------------------------------------
            Console.WriteLine("\n\tMATRIZ DE INCIDÊNCIA");
            Console.Write(" ");
            foreach (string obj in _TodasArestas)
            {
                Console.Write(" " + obj);
            }
            Console.WriteLine("\n");
            foreach (Vertice obj in _verticesGrafo)
            {
                Console.Write(obj.Nome);
                foreach (string second in _TodasArestas)
                {
                    if (obj.Arestas.Where(x => x.NomeAresta == second).FirstOrDefault() != null)
                    {
                        Console.Write(" S");
                    }
                    else
                    {
                        Console.Write(" N");
                    }
                }
                Console.WriteLine("\n");
            }


            Vertice _GrauMaior = _verticesGrafo.OrderByDescending(y => y.Arestas.Count()).FirstOrDefault();

            Console.WriteLine("VÉRTICE DE MAIOR GRAU: " + _GrauMaior.Nome + "\n");

            //Console.WindowHeight = 800;

            foreach (Vertice obj in _verticesGrafo)
            {
                Console.Write(obj.Nome + " - GRAU: " + obj.Arestas.Count() + " - VIZINHO: ");
                foreach (Aresta _aresta in obj.Arestas)
                {
                    if (_aresta.No2.Nome != obj.Nome)
                    {
                        Console.Write("\t" + _aresta.No2.Nome);
                    }
                    else
                    {
                        Console.Write("\t" + _aresta.No1.Nome);
                    }
                }
                Console.WriteLine("\n");
            }

            for (int a = 0; a < count; a++)
            {
                for (int b = 0; b < count; b++)
                {
                    Console.Write("\t" + MatrizAdjacencia[a, b]);
                }
                Console.Write("\n");
            }

            Dijkstra minimo    = new Dijkstra();

            minimo.TotalVertices = count - 1;
            minimo.Calcular(MatrizAdjacencia, 0, count - 1);

            Console.ReadLine();
            //Console.Write(obj.Nome + " - " + obj.Arestas.f);
            //Console.WriteLine("VIZINHOS: ")

            /**
             *      1       3
             * A ------ e ---C
             * |        |   /
             * | 6    4 |  /2
             * |        | /
             * B------- D/
             *      8
             *
             *      A = 0
             *      E = 1
             *      B = 2
             *      D = 3
             *      C = 4
             *
             **/
        }
コード例 #10
0
 public Arista(Vertice inicio, Vertice fin)
 {
     Inicio = inicio;
     Fin    = fin;
 }
コード例 #11
0
ファイル: Form1.cs プロジェクト: sancas/ProgramacionIV
 private void eliminarVerticeToolStripMenuItem_Click(object sender, EventArgs e)
 {
     ventanaVertice = new Vertice("Eliminar Nodo"); //eliminarnodo crea una ventana Eliminarcs con el valor de 1
     ventanaVertice.Visible = false; //Se actualiza el dato Visible
     ventanaVertice.control = false; //Se asigna false a control antes de mostrar el form
     ventanaVertice.ShowDialog(); //Muestra el dialogo para eliminar un nodo
     if (ventanaVertice.control)
     {
         if (grafo.BuscarVertice(ventanaVertice.txtVertice.Text.Trim()) != null) //si se encuentra el nodo
         {
             grafo.EliminarVertice(grafo.BuscarVertice(ventanaVertice.txtVertice.Text.Trim())); //Elimina un nodo con tener el valor string de este
             grafo.ReestablecerGrafo(Pizarra.CreateGraphics()); //Se reestablece el grafo y se redibuja para quitar el nodo
             Pizarra.Refresh(); //Se refresca el canvas
         }
         else //si no
         {
             MetroMessageBox.Show(this, "El nodo " + ventanaVertice.Text + " no  se encuentra en el grafo", " Error Nodo", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
         }
     }
 }
コード例 #12
0
        public void desConectar(Vertice <T> origen, Vertice <T> destino)
        {
            Arista <T> arista = origen.getAdyacentes().Find(a => a.getDestino().Equals(destino));

            origen.getAdyacentes().Remove(arista);
        }
コード例 #13
0
 public void conectar(Vertice <T> origen, Vertice <T> destino, int peso)
 {
     origen.getAdyacentes().Add(new Arista <T>(destino, peso));
 }
コード例 #14
0
 public void eliminarVertice(Vertice <T> v)
 {
     vertices.Remove(v);
 }
コード例 #15
0
 public void agregarVertice(Vertice <T> v)
 {
     v.setPosicion(vertices.Count + 1);
     vertices.Add(v);
 }
コード例 #16
0
 public void ConectarArestas(Vertice n_vertice, string NomeAresta, int Peso)
 {
     Aresta.Criar(n_vertice, this, NomeAresta, Peso);
 }
コード例 #17
0
 public static Aresta Criar(Vertice node1, Vertice node2, string Nome, int peso)
 {
     return(new Aresta(node1, node2, Nome, peso));
 }
コード例 #18
0
 public Arista(Vertice <T> dest, int p)
 {
     destino = dest;
     peso    = p;
 }
コード例 #19
0
ファイル: Form1.cs プロジェクト: sancas/ProgramacionIV
 private void recorridoProfundidadToolStripMenuItem_Click(object sender, EventArgs e)
 {
     ventanaVertice = new Vertice("Recorrido en Profundidad");
     ventanaVertice.Visible = false; //Se define el visible de la ventana recorrido como false
     ventanaVertice.control = false; //Se define la variable de control de la ventana recorrido como false
     ventanaVertice.ShowDialog(); //Se muestra la ventana Recorrido
     if (ventanaVertice.control) //Si todo fue bien
     {
         if (grafo.BuscarVertice(ventanaVertice.txtVertice.Text) != null) //Si el grafo seleccionado se encuentra
         {
             RecorridoProfundidad(grafo.BuscarVertice(ventanaVertice.txtVertice.Text));
         }
         else //Sino error
         {
             MessageBox.Show("Ese Nodo no se encuentra en el grafo", "Error Nodo", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
         }
     }
     grafo.ReestablecerGrafo(Pizarra.CreateGraphics()); //Se reestablece el grafo
     Pizarra.Refresh(); //Se refresca el canvas
 }
コード例 #20
0
 public void setDestino(Vertice <T> destino)
 {
     this.destino = destino;
 }
コード例 #21
0
 public Aresta(Vertice v1, Vertice v2, int peso)
 {
     this.Peso = peso;
     this.V1   = v1;
     this.V2   = v2;
 }
コード例 #22
0
        public void inserir_vertice(int id)
        {
            Vertice v = new Vertice(id);

            vertices[id] = v;
        }