// *********************************************************************
        // Wczytuje graf z podanej tablicy, bedacej macierza sasiedztwa.
        // Wyrzuca IncorrectGraphException w przypadku, gdy tablica zawiera
        // nieprawidlowe informacje. Zwraca poprawna macierz sasiedztwa.
        // *********************************************************************

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

            int[][] matrix = MatrixGraphGenerator.CreateMatrix(graph.Length);

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

                for (int j = 0; j < graph[i].Length; j++)
                {
                    matrix[i][j] = graph[i][j];
                }
            }

            if (!MatrixGraphValidator.ValidateGraph(matrix))
            {
                throw new IncorrectGraphException();
            }

            return(matrix);
        }
        // *********************************************************************
        // Wczytuje graf z podanej tablicy krawedzi i zwraca macierz sasiedztwa.
        // Wyrzuca IncorrectGraphException w przypadku, gdy tablica zawiera
        // nieprawidlowe informacje.
        // *********************************************************************

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

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

            // Stworzenie nowej macierzy:
            int[][] graph = MatrixGraphGenerator.CreateMatrix(maxVertex + 1);

            foreach (Edge edge in edges)
            {
                graph[edge.Start][edge.End] = edge.Weight;
                graph[edge.End][edge.Start] = edge.Weight;
            }

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

            return(graph);
        }
        // *********************************************************************
        // Generuje i zwraca w postaci macierzy 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);

            // Utworzenie macierzy o odpowiednim rozmiarze.
            int[][] graph = CreateMatrix(vertices);

            // Zapewnienie jednego polaczenia dla kazdego wierzcholka
            // z losowym innym wierzcholkiem:
            CreateMinimalEdges(graph, maxWeight);

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

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

            return(graph);
        }
Exemple #4
0
        // *********************************************************************
        // Zwraca minimalna wage z grafu (w szczegolnosci 0, jesli graf
        // nie istnieje).
        // *********************************************************************

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

            MatrixGraphValidator.ValidateGraph(matrix);
            return(matrix.Min(i => i.Min(j => (j > 0) ? j : int.MaxValue)));
        }
        // *********************************************************************
        // Wczytuje graf z pliku o podanej nazwie (postac macierzowa).
        // Wyrzuca wyjatek FileNotFoundException wprzypadku nieznalezienia pliku
        // lub FileCorruptedException w przypadku, gdy plik zawiera
        // niepoprawne dane. Zwraca wczytana macierz sasiedztwa.
        // *********************************************************************

        public static int[][] LoadMatrix(string filename)
        {
            if (File.Exists(filename))
            {
                int[][]      matrix;
                StreamReader reader = new StreamReader(filename);

                string[] splittedLine = Regex.Split(reader.ReadLine(), @"\s+");
                int      vertices     = 0;
                int      weight;

                foreach (string s in splittedLine)
                {
                    if (int.TryParse(s, out weight))
                    {
                        vertices++;
                    }
                    else
                    {
                        throw new FileCorruptedException();
                    }
                }

                if (vertices > 0)
                {
                    matrix = MatrixGraphGenerator.CreateMatrix(vertices);

                    for (int i = 0; i < vertices; i++)
                    {
                        matrix[0][i] = int.Parse(splittedLine[i]);
                    }

                    int line = 1;

                    while (!reader.EndOfStream)
                    {
                        splittedLine = Regex.Split(reader.ReadLine(), @"\s+");

                        if (splittedLine.Length != vertices)
                        {
                            throw new FileCorruptedException();
                        }

                        if (line > vertices)
                        {
                            throw new FileCorruptedException();
                        }

                        for (int j = 0; j < vertices; j++)
                        {
                            if (int.TryParse(splittedLine[j], out weight))
                            {
                                matrix[line][j] = weight;
                            }
                            else
                            {
                                throw new FileCorruptedException();
                            }
                        }

                        line++;
                    }
                }
                else
                {
                    throw new FileCorruptedException();
                }

                reader.Close();

                if (!MatrixGraphValidator.ValidateGraph(matrix))
                {
                    throw new IncorrectGraphException();
                }

                return(matrix);
            }
            else
            {
                throw new FileNotFoundException();
            }
        }