Beispiel #1
0
        public List <int> dijkstra(int a, int x)
        {
            Graf                    grafdijkstry = new Graf(0, 0);
            List <Krawedz>          kolejka      = new List <Krawedz>();
            List <int>              droga        = new List <int>();
            List <int>              p            = new List <int>();
            List <int>              d            = new List <int>();
            List <SortedSet <int> > holes        = new List <SortedSet <int> >();

            for (int i = 0; i < wezly.Count; i++)
            {
                p.Add(-1);
                d.Add(777777);
                holes.Add(new SortedSet <int> {
                    0
                });
            }
            d[0]     = 0;
            holes[0] = new SortedSet <int> {
                0, 1, 2, 3, 4, 5, 6, 7
            };

            krawedzie[2].szczeliny.Add(3);
            krawedzie[4].szczeliny.Add(3);
            krawedzie[3].szczeliny.Add(3);
            krawedzie[0].szczeliny.Add(3);

            for (int i = 0; i < krawedzie.Count; i++)
            {
                if (krawedzie[i].PodajPoczatek() == a)
                {
                    kolejka.Add(krawedzie[i]);
                }
            }
            foreach (var krawedz in kolejka)
            {
                droga.Add(krawedz.PodajWage());
            }

            Console.WriteLine(droga[1]);
            grafdijkstry.wezly.Add(wezly[a - 1]);
            grafdijkstry.iloscwezlow++;

            int     min  = 12345677;
            int     kraw = 0;
            bool    war1 = false;
            Krawedz actualEdge;

            while (grafdijkstry.iloscwezlow != iloscwezlow)
            {
                min  = 7777777;
                war1 = false;
                for (int i = 0; i < droga.Count; i++)
                {
                    if (droga[i] < min)
                    {
                        min  = droga[i];
                        kraw = i;
                    }
                }
                int kkk = 0;
                Console.WriteLine(kolejka[kraw].PodajPoczatek());
                Console.WriteLine(kolejka[kraw].PodajKoniec());

                actualEdge = kolejka[kraw];
                for (int j = 0; j < grafdijkstry.wezly.Count; j++)
                {
                    if (actualEdge.PodajKoniec() == grafdijkstry.wezly[j].PodajId())
                    {
                        war1 = true;
                    }
                }

                if (war1 == false)
                {
                    if (d[actualEdge.PodajKoniec() - 1] > d[actualEdge.PodajPoczatek() - 1] + actualEdge.PodajWage())
                    {
                        p[actualEdge.PodajKoniec() - 1] = actualEdge.PodajPoczatek();
                        d[actualEdge.PodajKoniec() - 1] = d[actualEdge.PodajPoczatek() - 1] + actualEdge.PodajWage();
                        SortedSet <int> hs = new SortedSet <int>();
                        foreach (int liczba in holes[actualEdge.PodajPoczatek() - 1])
                        {
                            hs.Add(liczba);
                        }
                        hs.IntersectWith(actualEdge.podajSzeliny());
                        holes[actualEdge.PodajKoniec() - 1].Clear();
                        foreach (int liczba in hs)
                        {
                            holes[actualEdge.PodajKoniec() - 1].Add(liczba);
                        }
                    }

                    grafdijkstry.krawedzie.Add(actualEdge);
                    grafdijkstry.ilosckrawedzi++;
                    grafdijkstry.wezly.Add(wezly[actualEdge.PodajKoniec() - 1]);
                    grafdijkstry.iloscwezlow++;

                    for (int i = 0; i < krawedzie.Count; i++)
                    {
                        if (krawedzie[i].PodajPoczatek() == actualEdge.PodajKoniec())
                        {
                            bool war2 = false;
                            for (int j = 0; j < kolejka.Count; j++)
                            {
                                if (krawedzie[i].PodajKoniec() == kolejka[j].PodajPoczatek() && krawedzie[i].PodajPoczatek() == kolejka[j].PodajKoniec())
                                {
                                    war2 = true;
                                }
                            }
                            if (war2 == false)
                            {
                                kolejka.Add(krawedzie[i]);
                                droga.Add(krawedzie[i].PodajWage() + droga[kraw]);
                            }
                        }
                    }
                }
                kolejka.RemoveAt(kraw);
                droga.RemoveAt(kraw);
            }
            Console.WriteLine("--------------------------------------------------");
            for (int i = 0; i < wezly.Count; i++)
            {
                Console.WriteLine("Tablica d: " + d[i]);
            }
            Console.WriteLine("--------------------------------------------------");
            for (int i = 0; i < wezly.Count; i++)
            {
                Console.WriteLine("Tablica p: " + p[i]);
            }
            Console.WriteLine("--------------------------------------------------");

            Console.WriteLine("Tablica szczelinowa: ");
            foreach (SortedSet <int> bb in holes)
            {
                foreach (int y in bb)
                {
                    Console.Write(y + " ");
                }
                Console.WriteLine();
            }
            Console.WriteLine("--------------------------------------------------");


            Graf dijkstra2     = new Graf(0, 0);
            int  lastestNode   = x;
            int  nextNodeToAdd = 0;

            while (a != lastestNode)
            {
                dijkstra2.wezly.Add(wezly[lastestNode - 1]);
                dijkstra2.iloscwezlow++;
                nextNodeToAdd = p[lastestNode - 1];
                if (podajKrawedz(nextNodeToAdd, lastestNode) == -1)
                {
                    dijkstra2.iloscwezlow = 0;
                    break;
                }

                dijkstra2.krawedzie.Add(krawedzie[podajKrawedz(nextNodeToAdd, lastestNode) - 1]);
                dijkstra2.ilosckrawedzi++;
                lastestNode = nextNodeToAdd;
            }

            if (dijkstra2.iloscwezlow > 0)
            {
                dijkstra2.wezly.Add(wezly[lastestNode - 1]);
                dijkstra2.iloscwezlow++;
            }

            List <int> returnValue = new List <int>();

            Console.WriteLine("TTTTTT: " + d[x - 1]);
            returnValue.Add(d[x - 1]);
            returnValue.Add(-777);
            foreach (int number in returnContinuousSzczeliny(holes[x - 1]))
            {
                returnValue.Add(x);
            }
            returnValue.Add(-777);
            foreach (Wezel wezel in dijkstra2.wezly)
            {
                returnValue.Add(wezel.PodajId());
            }
            return(returnValue);
        }
Beispiel #2
0
        public Graf dijkstraSzczeliny(int a, int x)
        {
            Graf                    grafdijkstry = new Graf(0, 0);
            List <Krawedz>          kolejka      = new List <Krawedz>();
            List <double>           droga        = new List <double>();
            List <SortedSet <int> > holes        = new List <SortedSet <int> >();
            List <int>              pholes       = new List <int>();

            for (int i = 0; i < wezly.Count; i++)
            {
                pholes.Add(-1);
                holes.Add(new SortedSet <int> {
                    0
                });
            }
            holes[0] = new SortedSet <int> {
                0, 1, 2, 3, 4, 5, 6, 7
            };
            krawedzie[8].szczeliny.Add(3);
            krawedzie[9].szczeliny.Add(3);
            krawedzie[5].szczeliny.Add(3);
            krawedzie[4].szczeliny.Add(3);
            for (int i = 0; i < krawedzie.Count; i++)
            {
                if (krawedzie[i].PodajPoczatek() == a)
                {
                    kolejka.Add(krawedzie[i]);
                }
            }
            foreach (var krawedz in kolejka)
            {
                droga.Add(countContinuousSzczeliny(krawedz));
            }


            grafdijkstry.wezly.Add(wezly[a - 1]);
            grafdijkstry.iloscwezlow++;

            double  max  = -1;
            int     kraw = 0;
            bool    war1 = false;
            Krawedz actualEdge;

            while (grafdijkstry.iloscwezlow != iloscwezlow)
            {
                max  = -1;
                war1 = false;
                for (int i = 0; i < droga.Count; i++)
                {
                    if (droga[i] > max)
                    {
                        max  = droga[i];
                        kraw = i;
                    }
                }
                actualEdge = kolejka[kraw];
                for (int j = 0; j < grafdijkstry.wezly.Count; j++)
                {
                    if (actualEdge.PodajKoniec() == grafdijkstry.wezly[j].PodajId())
                    {
                        war1 = true;
                    }
                }

                if (war1 == false)
                {
                    Console.WriteLine(kolejka[kraw].PodajKoniec());

                    SortedSet <int> hs = new SortedSet <int>();
                    foreach (int liczba in holes[actualEdge.PodajPoczatek() - 1])
                    {
                        hs.Add(liczba);
                    }
                    hs.IntersectWith(actualEdge.podajSzeliny());
                    if (hs.Count >= holes[actualEdge.PodajKoniec() - 1].Count)
                    {
                        holes[actualEdge.PodajKoniec() - 1].Clear();
                        foreach (int liczba in hs)
                        {
                            holes[actualEdge.PodajKoniec() - 1].Add(liczba);
                        }
                        pholes[actualEdge.PodajKoniec() - 1] = actualEdge.PodajPoczatek();
                    }


                    grafdijkstry.krawedzie.Add(actualEdge);
                    grafdijkstry.ilosckrawedzi++;
                    grafdijkstry.wezly.Add(wezly[actualEdge.PodajKoniec() - 1]);
                    grafdijkstry.iloscwezlow++;
                    for (int i = 0; i < krawedzie.Count; i++)
                    {
                        if (krawedzie[i].PodajPoczatek() == actualEdge.PodajKoniec())
                        {
                            bool war2 = false;
                            for (int j = 0; j < kolejka.Count; j++)
                            {
                                if (krawedzie[i].PodajKoniec() == kolejka[j].PodajPoczatek() && krawedzie[i].PodajPoczatek() == kolejka[j].PodajKoniec())
                                {
                                    war2 = true;
                                }
                            }
                            if (war2 == false)
                            {
                                kolejka.Add(krawedzie[i]);
                                //droga.Add(grafdijkstry.wezly.Find(krawedzie[i].PodajKoniec()));
                                //TUTAJ TRZEBA WSTAWIAC MAX SZCZELINY!!!!!
                                SortedSet <int> s1 = new SortedSet <int>()
                                {
                                    1, 2, 3, 4, 5, 6, 7
                                };
                                s1.IntersectWith(holes[krawedzie[i].PodajPoczatek() - 1]);
                                s1.IntersectWith(krawedzie[i].szczeliny);
                                droga.Add(countContinuousSzczeliny(s1));
                            }
                        }
                    }
                }
                kolejka.RemoveAt(kraw);
                droga.RemoveAt(kraw);
            }
            Console.WriteLine("--------------------------------------------------");
            for (int i = 0; i < wezly.Count; i++)
            {
                Console.WriteLine("Tablica holes: " + holes[i]);
                Console.WriteLine("Tablica pholes: " + pholes[i]);
            }

            Graf dijkstra2     = new Graf(0, 0);
            int  lastestNode   = x;
            int  nextNodeToAdd = 0;

            while (a != lastestNode)
            {
                dijkstra2.wezly.Add(wezly[lastestNode - 1]);
                dijkstra2.iloscwezlow++;
                nextNodeToAdd = pholes[lastestNode - 1];
                if (podajKrawedz(nextNodeToAdd, lastestNode) == -1)
                {
                    dijkstra2.iloscwezlow = 0;
                    break;
                }

                dijkstra2.krawedzie.Add(krawedzie[podajKrawedz(nextNodeToAdd, lastestNode) - 1]);
                dijkstra2.ilosckrawedzi++;
                lastestNode = nextNodeToAdd;
            }

            if (dijkstra2.iloscwezlow > 0)
            {
                dijkstra2.wezly.Add(wezly[lastestNode - 1]);
                dijkstra2.iloscwezlow++;
            }

            return(dijkstra2);
        }