示例#1
0
        public override Grafo complemento(Graphics g)
        {
            NodoP  nn;
            Arista nnr;

            Grafo nuevo = new Grafo();

            foreach (NodoP np in this)
            {
                nn = new NodoP(np.nombre, np.centro);
                nuevo.Add(nn);
            }
            nuevo = new GrafoNoDirigido(nuevo);

            foreach (NodoP aux1 in this)                // Ciclo que recorre los nodos del grafo
            {
                if (aux1.aristas.Count == 0)            // si el nodo no tiene aristas
                {
                    foreach (NodoP aux2 in nuevo)       // Ciclo que recorre los nodos del grafo "copia"
                    {
                        if (aux1.nombre != aux2.nombre) // Condición para que el nodo no apunte a si mismo
                        {
                            nnr         = new Arista(0);
                            nnr.origen  = nuevo.Find(x => x.nombre.Equals(aux1.nombre));
                            nnr.destino = aux2;

                            nuevo.Find(x => x.nombre.Equals(aux1.nombre)).aristas.Add(nnr);
                        }
                    }
                }

                else // Si el nodo ya tiene Aristas
                {
                    foreach (NodoP aux2 in nuevo) // Ciclo que recorre los nodos
                    {
                        if (aux1.nombre != aux2.nombre) // Compara que el nodo no se apunte a si mismo
                        {
                            Arista r = new Arista(0);
                            r = aux1.aristas.Find(x => x.destino.nombre.Equals(aux2.nombre));
                            if (r == null)
                            {
                                nnr         = new Arista(0);
                                nnr.origen  = nuevo.Find(x => x.nombre.Equals(aux1.nombre));
                                nnr.destino = aux2;
                                if (nnr != null)
                                {
                                    nuevo.Find(x => x.nombre.Equals(aux1.nombre)).aristas.Add(nnr);
                                }
                            }
                            else
                            {
                                continue;
                            }
                        }
                    }
                }
            }

            base.complemento(g);

            return(nuevo);
        }
示例#2
0
 public void push(NodoP nuevo)
 {
     nodos.Add(nuevo);
     tope = nodos.Count - 1;
 }
示例#3
0
        private void Form1_MouseDown(object sender, MouseEventArgs e)
        {
            p1 = e.Location;
            if (activa)
            {
                nodoW  = grafo.BuscaNodo(p1);
                activa = false;
            }

            switch (opcion)
            {
            case 1:
                if (/*grafo.Count == 1 &&*/ grafo.numN == 1)
                {
                    CambiaBotones(true);
                }
                grafo.numN++;
                if (grafo.Count > 0)
                {
                    nodoP = new NodoP(grafo.Count - 1, p1);
                }
                else
                {
                    nodoP = new NodoP(grafo.numN - 1, p1);
                }
                grafo.Add(nodoP);
                grafo.nomb   = nodoP.nombre;
                nodoP.nombre = grafo.Count;
                band         = false;
                bandF        = true;
                if (grafo.numN == 28 && grafo.Count == 28)
                {
                    bandI        = true;
                    grafo.edoNom = true;
                }
                else
                {
                    bandI = false;
                }
                Form1_Paint(this, null);
                break;

            case 2:
            case 9:
                nodoP = grafo.BuscaNodo(p1);
                if (nodoP != null)
                {
                    band  = true;
                    bandA = true;
                }
                else
                {
                    band = false;
                }
                break;

            case 3:
                nodoP = grafo.BuscaNodo(p1);
                if (nodoP != null)
                {
                    bandA = true;
                }
                else
                {
                    band = false;
                }
                break;

            case 8:
                p1 = e.Location;

                warnerButton.Enabled = true;
                break;
            }
        }
示例#4
0
        /****************************************************************************************
        * BOSQUE ABARCADOR EN PROFUNDIDAD
        * 1) Posicionar en el primer nodo
        * 2) Agregar nodo a lista de listas ( bosque )
        * 3) Ciclo que recorre las relaciones del nodo
        * 4) Validar si tiene
        *
        ****************************************************************************************/

        public void bosqueAbarcador()
        {
            bosque = new List <List <NodoP> >();
            NodoP aux;

            aux   = grafo[0];
            nodos = new List <NodoP>();
            bosque.Add(new List <NodoP>());

            while (aux != null)
            {
                NodoP existeP = stack.nodos.Find(x => x.Equals(aux));
                if (existeP == null)
                {
                    bosque[0].Add(aux); // Se añade A
                    stack.push(aux);
                }
                bool tv2 = todoVisitado(aux);
                if (tv2 == true)
                {
                    if (stack.tope == 1)
                    {
                        break;
                    }
                    stack.pop();
                    aux = stack.ultimo();
                }
                // Se recorren sus relaciones
                foreach (Arista nr in aux.aristas)
                {
                    // Verificar si la arista ha sido visitada
                    if (visitado == null)
                    {
                        visitado = new List <Arista>();
                    }
                    Arista existeA = visitado.Find(x => x.Equals(nr));

                    if (existeA == null) // La arista aun no ha sido visitada
                    {
                        //verificar si nodo destino existe
                        bool existeNodo = encuentraEnBosque(bosque, nr.destino);

                        if (existeNodo == false)
                        {
                            if (arbol == null)
                            {
                                arbol = new List <Arista>();
                            }
                            arbol.Add(nr);
                            aux = nr.destino;
                        }
                        else // El nodo ya existe en el bosque
                        {
                            // validar si es retroceso o avance
                            int posA = damePosicion(bosque, aux);
                            int posB = damePosicion(bosque, nr.destino);

                            if (posA < posB)
                            {
                                // avance
                                if (avance == null)
                                {
                                    avance = new List <Arista>();
                                }
                                avance.Add(nr);
                            }
                            else if (posA > posB)
                            {
                                // retroceso
                                if (retroceso == null)
                                {
                                    retroceso = new List <Arista>();
                                }
                                retroceso.Add(nr);
                            }
                        }
                        visitado.Add(nr);
                        // Si todas sus relaciones ya fueron visitadas
                        bool tv = todoVisitado(aux);
                        if (tv == true)
                        {
                            stack.pop();
                            aux = stack.ultimo();
                        }


                        break;
                    }
                }
            }
        }
示例#5
0
        private void Archivo_Click(object sender, ToolStripItemClickedEventArgs e)
        {
            opcion = 0;
            NodoP A    = null;
            bool  band = false;
            int   i    = 0;

            iKruskal             = 0;
            bpar                 = false;
            intercambiaColor     = false;
            agregaPeso.BackColor = Color.Gray;
            quitaPesos();
            quitaNumeric();
            if (bpar == false)
            {
                grafo.ImprimirGrafo(g, bpar);
            }

            IFormatter formatter  = new BinaryFormatter();
            String     directorio = Environment.CurrentDirectory + "..\\Grafos";

            //String directorio = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, @"..\\Grafos"));



            switch (e.ClickedItem.AccessibleName)
            {
            case "Save":
                saveFileDialog1.InitialDirectory = directorio;
                saveFileDialog1.FileName         = "";
                saveFileDialog1.Filter           = "(*.grafo)|*.grafo";
                if (saveFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                {
                    Stream stream = new FileStream(saveFileDialog1.FileName, FileMode.Create, FileAccess.Write, FileShare.None);


                    if (grafo.tipo == 1)
                    {
                        formatter.Serialize(stream, (Grafo)grafo);
                    }
                    else if (grafo.tipo == 2)
                    {
                        formatter.Serialize(stream, (GrafoNoDirigido)grafo);
                    }
                    else if (grafo.tipo == 3)
                    {
                        formatter.Serialize(stream, (GrafoDirigido)grafo);
                    }


                    stream.Close();
                }
                break;

            case "Open":
                openFileDialog1.FileName         = "";
                openFileDialog1.Filter           = "(*.grafo)|*.grafo";
                openFileDialog1.InitialDirectory = directorio;
                if (openFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                {
                    g.Clear(BackColor);
                    grafo.Clear();
                    AristaNoDirigida.Enabled = true;
                    AristaDirigida.Enabled   = true;
                    Stream stream = new FileStream(openFileDialog1.FileName, FileMode.Open, FileAccess.Read, FileShare.None);

                    grafo = (Grafo)formatter.Deserialize(stream);

                    if (grafo.tipo == 2)    // GRAFO NO DIRIGIDO
                    {
                        obtenPropiedades();
                        asignaPropiedades();
                        grafo = new GrafoNoDirigido(grafo);
                        AristaNoDirigida.Enabled = true;
                        AristaDirigida.Enabled   = false;
                        euleriano.Enabled        = true;
                        dijkstra.Enabled         = false;
                        kruskal.Enabled          = false;
                        agregaPeso.Enabled       = true;
                        toolStripButton2.Enabled = true;
                    }
                    else if (grafo.tipo == 3)    // GRAFO DIRIGIDO
                    {
                        obtenPropiedades();
                        asignaPropiedades();
                        grafo = new GrafoDirigido(grafo);
                        AristaNoDirigida.Enabled = false;
                        AristaDirigida.Enabled   = true;
                        grafo.penA.CustomEndCap  = arrow;
                        euleriano.Enabled        = false;
                        dijkstra.Enabled         = true;

                        agregaPeso.Enabled       = true;
                        kruskal.Enabled          = true;
                        toolStripButton2.Enabled = true;
                    }

                    stream.Close();



                    band  = false;
                    bandA = false;
                    bandF = false;
                    bandI = false;

                    MueveNodo.Enabled  = true;
                    BorrarNodo.Enabled = true;
                    // AristaNoDirigida.Enabled = true;
                    //  AristaDirigida.Enabled = true;
                    BorrarArista.Enabled  = true;
                    MueveGrafo.Enabled    = true;
                    BorrarGrafo.Enabled   = true;
                    EliminarGrafo.Enabled = true;
                    Cambia.Enabled        = true;
                    Invalidate();
                }
                break;

            case "Imprimir":
                opcion = 10;
                band   = false;
                bandF  = false;
                bandA  = false;
                bandI  = true;
                Invalidate();
                break;
            }
        }