Ejemplo n.º 1
0
        // *********************************************************************
        // Wczytuje graf z podanej tablicy krawedzi i zwraca liste sasiedztwa.
        // Wyrzuca IncorrectGraphException w przypadku, gdy tablica zawiera
        // nieprawidlowe informacje.
        // *********************************************************************

        public static int[][][] Load(Edge[] edges)
        {
            if (!ListGraphValidator.ValidateEdges(edges))
            {
                throw new IncorrectGraphException();
            }

            // Znalezienie maksymalnego wierzcholka maxVertex:
            int maxVertex = edges.Max(e => Math.Max(e.Start, e.End));

            // Utworzenie listy sasiedztwa i zainicjowanie jej:
            List <int[]>[] graph = new List <int[]> [maxVertex + 1];

            for (int i = 0; i < graph.Length; i++)
            {
                graph[i] = new List <int[]>();
            }

            // Dodanie do listy przekazanych metodzie krawedzi:
            edges.ToList().ForEach(
                e => ListGraphGenerator.InsertConnection(
                    graph, e.Start, e.End, e.Weight));

            if (!ListGraphValidator.ValidateGraph(graph))
            {
                throw new IncorrectGraphException();
            }

            return(graph.Select(i => i.ToArray()).ToArray());
        }
Ejemplo n.º 2
0
        // *********************************************************************
        // Generuje i zwraca w postaci listy sasiedztwa losowy graf o zadanej
        // liczbie wierzcholkow i procentowej gestosci (max. 100; min. gestosc
        // jest automatycznie dostosowywana, jednak deklarowana nie moze byc
        // mniejsza niz 1), uwzgledniajac maksymalna wage krawedzi.
        // W pzypadku niepoprawnych parametrow, graf nie zostanie wygenerowany
        // i zwrocona zostanie wartosc null.
        // *********************************************************************

        public static int[][][] Generate(
            int vertices, int density, int maxWeight)
        {
            // Jesli podane dane sa niepoprawne, zwroc null.
            if (vertices < 2 || density < 1 || density > 100 || maxWeight < 1)
            {
                return(null);
            }

            // Obliczenie liczby krawedzi na podstawie gestosci:
            int edges = CalculateEdges(vertices, density);

            // Zapewnienie jednego polaczenia dla kazdego wierzcholka
            // z losowym innym wierzcholkiem:
            List <int[]>[] graph = CreateMinimalEdges(vertices, maxWeight);

            // Dopelnienie grafu pozostalymi krawedziami:
            CompleteEdges(graph, edges - vertices + 1, maxWeight);

            // Sortowanie elementow list w kolejnosci rosnacej:
            graph.ToList().ForEach(a => a.Sort((i, j) => i[0].CompareTo(j[0])));

            // Sprawdzenie poprawnosci wygenrowanyego grafu:
            if (!ListGraphValidator.ValidateGraph(graph))
            {
                throw new IncorrectGraphException();
            }

            return(graph.Select(i => i.ToArray()).ToArray());
        }
Ejemplo n.º 3
0
        // *********************************************************************
        // Zwraca minimalna wage z grafu (w szczegolnosci 0, jesli graf
        // nie istnieje).
        // *********************************************************************

        public int Min()
        {
            if (list == null || list.Length == 0)
            {
                return(0);
            }

            ListGraphValidator.ValidateGraph(list);
            return(list.Min(i => i.Min(j => (j[1] > 0) ? j[1] : int.MaxValue)));
        }
Ejemplo n.º 4
0
        // *********************************************************************
        // Wczytuje graf z podanej tablicy, bedacej lista sasiedztwa.
        // Wyrzuca IncorrectGraphException w przypadku, gdy tablica zawiera
        // nieprawidlowe informacje. Zwraca poprawna liste sasiedztwa.
        // *********************************************************************

        public static int[][][] LoadList(int[][][] graph)
        {
            if (graph == null)
            {
                throw new IncorrectGraphException();
            }

            int[][][] list = new int[graph.Length][][];

            for (int i = 0; i < graph.Length; i++)
            {
                if (graph[i] == null || graph[i].Length == 0)
                {
                    throw new IncorrectGraphException();
                }

                list[i] = new int[graph[i].Length][];

                for (int j = 0; j < graph[i].Length; j++)
                {
                    if (graph[i][j] == null || graph[i][j].Length != 2)
                    {
                        throw new IncorrectGraphException();
                    }

                    list[i][j]    = new int[2];
                    list[i][j][0] = graph[i][j][0];
                    list[i][j][1] = graph[i][j][1];
                }
            }

            if (!ListGraphValidator.ValidateGraph(list))
            {
                throw new IncorrectGraphException();
            }

            return(list);
        }