// *********************************************************************
// 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);
}
// *********************************************************************
// 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();
}
}