public DijkstraItem minmunWeight(List <DijkstraItem> canidates, Graph g)
        {
            int minvalue;

            minvalue = int.MaxValue;
            DijkstraItem mindij = null;

            foreach (var dj in canidates)
            {
                if (dj.acumulateWeight < minvalue && !dj.isDefinitive)
                {
                    minvalue = dj.acumulateWeight;
                    mindij   = dj;
                }
            }
            Point        p     = new Point(-1, -1);
            Vertex       fa    = new Vertex(-1, -1, -1, -1);
            DijkstraItem nuevo = new DijkstraItem(fa);

            if (mindij == null)
            {
                mindij = nuevo;
            }
            nuevo.acumulateWeight = -1;

            return(mindij);
        }
        public List <DijkstraItem> Dijkstra(Graph g)
        {
            List <DijkstraItem> candidates = new List <DijkstraItem>();

            foreach (var v in g.vL)
            {
                candidates.Add(new DijkstraItem(v));
                if (v.id == origen.id)
                {
                    candidates.Last().acumulateWeight = 0;
                    candidates.Last().proveniente     = v;
                    candidates.Last().isDefinitive    = true;
                }
            }
            foreach (var a in origen.eL)
            {
                foreach (var dj in candidates)
                {
                    if (a.getDestiny() == dj.original)
                    {
                        dj.acumulateWeight = a.getEdgeW();
                        dj.proveniente     = origen;
                    }
                }
            }
            int iteraciones = 0;

            while (!solution(candidates))
            {
                iteraciones++;
                if (iteraciones > candidates.Count())
                {
                    return(candidates);
                }
                DijkstraItem minitem = minmunWeight(candidates, g);
                minitem.isDefinitive = true;
                foreach (var a in minitem.original.eL)
                {
                    foreach (var dj in candidates)
                    {
                        if (a.getDestiny() == dj.original)
                        {
                            if (minitem.acumulateWeight + a.getEdgeW() < dj.acumulateWeight)
                            {
                                dj.acumulateWeight = minitem.acumulateWeight + a.getEdgeW();
                                dj.proveniente     = minitem.original;
                            }
                        }
                    }
                }
            }
            return(candidates);
        }
        private void CaminoDijktra(DijkstraItem destination, Agent a, Graphics g)
        {
            Pen p = new Pen(Color.Yellow, 5);

            yes = true;
            DijkstraItem actual = destination;

            while (actual.proveniente != a.origen)
            {
                Edge aux = Vertex.findEdgeByVector(actual.original, actual.proveniente);
                dijstraPath.Add(aux);
                try
                {
                    foreach (Point po in aux.pL)
                    {
                        a.precomputed.Add(po);
                    }
                    pictureBox2.Refresh();
                    auxD = actual;
                    ed   = aux;
                    g.DrawLine(p, actual.original.getX(), actual.original.getY(), actual.proveniente.getX(), actual.proveniente.getY());
                    foreach (DijkstraItem d in items)
                    {
                        if (d.original == actual.proveniente)
                        {
                            actual = d;
                            break;
                        }
                    }
                }
                catch (Exception e)
                {
                    MessageBox.Show("el bait y el agente no se encuentran en el mismo arbol");
                    pictureBox2.Refresh();
                    return;
                }
            }
            Edge aux2 = Vertex.findEdgeByVector(actual.original, actual.proveniente);

            g2.DrawLine(p, actual.original.getX(), actual.original.getY(), a.origen.getX(), a.origen.getY());
            foreach (Point po in aux2.pL)
            {
                a.precomputed.Add(po);
            }
            dijstraPath.Add(aux2);
            a.precomputed.Reverse();
            g.Dispose();
            p.Dispose();
        }
        public Agent(Vertex o, int id)
        {
            this.origen = o;
            this.id     = id;

            vel          = 15;
            walkingIndex = 0;

            lastVertex = null;

            e_act    = null;
            this.rad = origen.getR();

            djItm       = null;
            precomputed = new List <Point>();
            pathDFS     = new List <Vertex>();
            pathDFS.Add(origen);
        }
        private void setAgent(int x, int y, Color c, bool isAnAgent)
        {
            Graphics g = Graphics.FromImage(graph);

            g2 = Graphics.FromImage(graph);
            Point p = new Point();

            int minDist = int.MaxValue;

            for (int i = 0; i < graf.getVertexCount(); i++)
            {
                Vertex v1 = graf.getVertexAt(i);

                int x0   = v1.getX();
                int y0   = v1.getY();
                int dist = distEu(x, y, x0, y0);
                if (dist < minDist)
                {
                    minDist = dist;
                    p.X     = x0;
                    p.Y     = y0;
                }
            }
            Vertex aux = graf.findVertex2(p);
            int    r   = aux.getR();

            g.FillEllipse(new SolidBrush(c), aux.getX() - r, aux.getY() - r, r * 2, r * 2);
            if (!aux.hasAgent && !aux.hasBait)
            {
                if (isAnAgent && a == null)
                {
                    a = new Agent(aux, -1);
                    g.FillEllipse(new SolidBrush(c), aux.getX() - r, aux.getY() - r, r * 2, r * 2);
                    aux.hasAgent = true;
                    items        = a.Dijkstra(graf);
                    foreach (var d in items)
                    {
                        if (d.acumulateWeight == int.MaxValue)                                                                     //si el peso del elemento dijstra sigue siendo "infinito"
                        {
                            listBox1.Items.Add("Desde: " + (a.origen.id + 1) + "A: " + (d.original.id + 1) + " no existe camino"); //significa que no existe un camino, es decir, nunca de modificó
                        }
                        else
                        {
                            listBox1.Items.Add("Desde: " + (a.origen.id + 1) + "A: " + (d.original.id + 1) + ", el peso es: " + d.acumulateWeight);
                        }
                    }
                }
                else
                {
                    //
                    if (a == null)
                    {
                        MessageBox.Show("Inserta un agente en el grafo primero :)");
                        //eg2.FillEllipse(new SolidBrush(Color.Orange), bait.original.getX() - r, bait.original.getY() - r, r * 2, r * 2);
                        goto End;
                    }
                    dijstraPath.Clear();
                    a.precomputed.Clear();
                    foreach (var d in items)
                    {
                        if (d.original.id == aux.id)
                        {
                            bait = d;
                            break;
                        }
                    }
                    g.Clear(Color.Transparent);
                    CaminoDijktra(bait, a, g);
                    g2.FillEllipse(new SolidBrush(Color.LightPink), a.origen.getX() - r, a.origen.getY() - r, r * 2, r * 2);
                    g2.FillEllipse(new SolidBrush(c), bait.original.getX() - r, bait.original.getY() - r, r * 2, r * 2);
                    pictureBox2.Refresh();
                    if (!yes)
                    {
                        g2.FillEllipse(new SolidBrush(Color.BlueViolet), bait.original.getX() - r, bait.original.getY() - r, r * 2, r * 2);
                    }
                    g2.Dispose();
                }
            }
            else
            {
                MessageBox.Show("Ya hay un agente o cebo en ese vértice");
            }
            End :;

            //pictureBox2.Refresh();
            g.Dispose();
        }