/// <summary>
/// Algorytm zależny od ilości pokolorowanych sąsiadów (im więcej tym większy priorytet).
/// </summary>
/// <param name="vertices">Lista wierzchołków w remisie</param>
/// <returns>Zwraca pokolorowany wierzchołek lub null, gdy nie pokolorowany.</returns>
private static Vertex ColorByColoredNeighborCount(List <Vertex> vertices)
{
Vertex coloredVertex = null;
if (vertices.Count < 2)
{
throw new Exception("Nieprawdidłowa lista sąsiadów");
}
// liczymy liczbę pomalowanych sąsiadów
vertices.ForEach(vertex =>
{
vertex.Neighbors.ForEach(neigh => vertex.ColoredNeighbors += neigh.Color != 0 ? 1 : 0);
});
//listę wierzchołków sortuję ich po ilości pokolorowanych sąsiadów
vertices = vertices.OrderByDescending(vertex => vertex.ColoredNeighbors)
.ToList();
// nadal jest jakiś remis
if (vertices[0].ColoredNeighbors == vertices[1].ColoredNeighbors)
{
var valueToCompare = vertices[0].ColoredNeighbors;
vertices = vertices.Where(vertex => vertex.ColoredNeighbors == valueToCompare).ToList();
return(coloredVertex);
}
coloredVertex = vertices[0];
PaintHelper.PaintVertex(coloredVertex);
return(coloredVertex);
}
/// <summary>
/// Algorytm zależny od ilości sąsiadów (im więcej tym większy priorytet).
/// </summary>
/// <param name="vertices">Lista wierzchołków w remisie</param>
/// <returns>Zwraca pokolorowany wierzchołek lub null, gdy nie pokolorowany.</returns>
private static Vertex ColorByNeighborCount(List <Vertex> vertices)
{
Vertex coloredVertex = null;
if (vertices.Count < 2)
{
throw new Exception("Nieprawdidłowa lista sąsiadów");
}
vertices = vertices.OrderByDescending(vertex => vertex.Neighbors.Count).ToList();
if (vertices[0].Neighbors.Count == vertices[1].Neighbors.Count)
{
var valueToCompare = vertices[0].Neighbors.Count;
vertices = vertices.Where(vertex => vertex.Neighbors.Count == valueToCompare).ToList();
return(coloredVertex);
}
coloredVertex = vertices[0];
PaintHelper.PaintVertex(coloredVertex);
return(coloredVertex);
}
/// <summary>
/// Algorytm zależny od ilości pokolorowanych sąsiadów (im więcej tym większy priorytet).
/// Liczony do momentu "remisu", czyli gdy więcej niż jeden wierzchołek ma taką samą liczbę pokolorowanych sąsiadów.
/// </summary>
/// <param name="vertices"></param>
/// <returns>Zwraca listę wierzchołków w remisie.</returns>
private static List <Vertex> ColorByColoredNeighborCountToTie(List <Vertex> vertices)
{
if (vertices.Count == 0)
{
return(vertices);
}
if (vertices.Count == 1)
{
PaintHelper.PaintVertex(vertices[0]);
vertices.RemoveAt(0);
return(vertices);
}
// liczymy liczbę pomalowanych sąsiadów
vertices.ForEach(vertex =>
{
vertex.Neighbors.ForEach(neigh => vertex.ColoredNeighbors += neigh.Color != 0 ? 1 : 0);
});
//listę wierzchołków sortuję ich po ilości pokolorowanych sąsiadów
vertices = vertices.OrderByDescending(vertex => vertex.ColoredNeighbors)
.ToList();
// jest jakiś "remis"
if (vertices[0].ColoredNeighbors == vertices[1].ColoredNeighbors)
{
var countToCompare = vertices[0].ColoredNeighbors;
return(vertices.Where(vertex => vertex.ColoredNeighbors == countToCompare).ToList());
}
PaintHelper.PaintVertex(vertices[0]);
vertices.Remove(vertices[0]);
return(ColorByColoredNeighborCountToTie(vertices));
}
/// <summary>
/// Algorytm zależny od ilości sąsiadów (im więcej tym większy priorytet).
/// Liczony do momentu "remisu", czyli gdy więcej niż jeden wierzchołek ma taką samą liczbę sąsiadów.
/// </summary>
/// <param name="vertices">Lista wierzchołków</param>
/// <returns>Zwraca listę wierzchołków w remisie.</returns>
private static List <Vertex> ColorByNeighborCountToTie(List <Vertex> vertices)
{
if (vertices.Count == 0)
{
return(vertices);
}
if (vertices.Count == 1)
{
PaintHelper.PaintVertex(vertices[0]);
vertices.RemoveAt(0);
return(vertices);
}
vertices = vertices.OrderByDescending(vertex => vertex.Neighbors.Count).ToList();
if (vertices[0].Neighbors.Count == vertices[1].Neighbors.Count)
{
var countToCompare = vertices[0].Neighbors.Count;
return(vertices.Where(vertex => vertex.Neighbors.Count == countToCompare).ToList());
}
PaintHelper.PaintVertex(vertices[0]);
vertices.Remove(vertices[0]);
return(ColorByNeighborCountToTie(vertices));
}
/// <summary>
/// Najpierw jest wykonywany algorytm zależny od ilości użytych barw w sąsiedztwie (im więcej tym większy priorytet).
/// Następnie wykonywany algorytm zależny od ilości sąsiadów (im więcej tym większy priorytet).
/// Następnie wykonywany jest algorytm zależny od ilości pokolorowanych sąsiadów.
/// </summary>
/// <param name="graph">Graf reprezentowany przez liczbę wszystkich wierzchołków</param>
/// <returns>Pokolorowane wierzchołki oraz 1 jeśli wszystkie wierzchołki zostały pomalowane. 0 jeśli jakiś jest niepomalowany.</returns>
public static int ColorsCountNeighborCountColoredNeibour(List <Vertex> graph)
{
// koloruje graf algorytmem zależnym od ilości użytych barw w sąsiedztwie "do remisu"
var verticesInTie = ColorByDiffColorsInNeighborhoodToTie(graph);
// nie było momentu remisu i kończę
if (verticesInTie.Count == 0)
{
return(1);
}
// koloruje wierzchołki w remisie algorytmem zależnym od ilości sąsiadów
var coloredVertex = ColorByNeighborCount(verticesInTie);
// udało się pomalować jeden wierzchołek i rekurencyjnie robimy tą funkcję jeszcze raz
if (coloredVertex != null)
{
graph.Remove(coloredVertex);
return(ColorsCountNeighborCountColoredNeibour(graph));
}
// koloruje wierzchołki w remisie algorytmem zależnym od ilości pokolorowanych sąsiadów
coloredVertex = ColorByColoredNeighborCount(verticesInTie);
// udało się pomalować jeden wierzchołek i rekurencyjnie robimy tą funkcję jeszcze raz
if (coloredVertex != null)
{
graph.Remove(coloredVertex);
return(ColorsCountNeighborCountColoredNeibour(graph));
}
// nie udało się pomalować ani jednego wierzchołka, więc koloruję pierwszego niepomalowanego
for (int i = 0; i < verticesInTie.Count; i++)
{
var vertex = verticesInTie[i];
if (vertex.Color == 0)
{
PaintHelper.PaintVertex(vertex);
graph.Remove(vertex);
return(ColorsCountNeighborCountColoredNeibour(graph));
}
}
return(0);
}
/// <summary>
/// Algorytm zależny od ilości użytych barw w sąsiedztwie (im więcej tym większy priorytet).
/// Liczony do momentu "remisu", czyli gdy więcej niż jeden wierzchołek ma taką samą liczbę różnych
/// kolorów wśród sąsiadów.
/// </summary>
/// <param name="vertices">Lista wierzchołków</param>
/// <returns>Zwraca listę wierzchołków w remisie.</returns>
private static List <Vertex> ColorByDiffColorsInNeighborhoodToTie(List <Vertex> vertices)
{
if (vertices.Count == 0)
{
return(vertices);
}
if (vertices.Count == 1)
{
PaintHelper.PaintVertex(vertices[0]);
vertices.RemoveAt(0);
return(vertices);
}
// liczymy wśród niepomalowanych wierzchołków liczbę użytych kolorów w ich sąsiedztwie
vertices.ForEach(vertex =>
{
vertex.Neighbors.ForEach(neigh =>
{
// jesli wierzchołek jest pomalowany i jego kolor nie znajduje się w dotychczasowych kolorach w sąsiedztwie
if (neigh.Color != 0 && !vertex.UsedColorsInNeighborhood.Any(x => x == neigh.Color))
{
vertex.UsedColorsInNeighborhood.Add(neigh.Color);
}
});
});
vertices = vertices.OrderByDescending(vertex => vertex.UsedColorsInNeighborhood.Count)
.ToList();
// jeśli jest jakiś remis
if (vertices[0].UsedColorsInNeighborhood.Count == vertices[1].UsedColorsInNeighborhood.Count)
{
var countToCompare = vertices[0].UsedColorsInNeighborhood.Count;
return(vertices.Where(vertex => vertex.UsedColorsInNeighborhood.Count == countToCompare).ToList());
}
PaintHelper.PaintVertex(vertices[0]);
vertices.Remove(vertices[0]);
return(ColorByDiffColorsInNeighborhoodToTie(vertices));
}
/// <summary>
/// Algorytm zależny od ilości użytych barw w sąsiedztwie (im więcej tym większy priorytet).
/// </summary>
/// <param name="vertices">Lista wierzchołków w remisie</param>
/// <returns>Zwraca pokolorowany wierzchołek lub null, gdy nie pokolorowany.</returns>
private static Vertex ColorByDiffColorsInNeighborhood(List <Vertex> vertices)
{
Vertex coloredVertex = null;
// liczymy wśród niepomalowanych wierzchołków liczbę użytych kolorów w ich sąsiedztwie
vertices.ForEach(vertex =>
{
vertex.Neighbors.ForEach(neigh =>
{
// jesli wierzchołek jest pomalowany i jego kolor nie znajduje się w dotychczasowych kolorach w sąsiedztwie
if (neigh.Color != 0 && !vertex.UsedColorsInNeighborhood.Any(x => x == neigh.Color))
{
vertex.UsedColorsInNeighborhood.Add(neigh.Color);
}
});
});
vertices = vertices.OrderByDescending(vertex => vertex.UsedColorsInNeighborhood.Count)
.ToList();
if (vertices[0].UsedColorsInNeighborhood.Count == vertices[1].UsedColorsInNeighborhood.Count)
{
var valueToCompare = vertices[0].UsedColorsInNeighborhood.Count;
vertices = vertices.Where(vertex => vertex.UsedColorsInNeighborhood.Count == valueToCompare).ToList();
return(coloredVertex);
}
coloredVertex = vertices[0];
PaintHelper.PaintVertex(coloredVertex);
return(coloredVertex);
}
/// <summary>
/// Najpierw jest wykonywany algorytm zależny od ilości sąsiadów (im więcej tym większy priorytet).
/// Następnie wykonywany jest algorytm zależny od ilości użytych barw w sąsiedztwie.
/// Następnie wykonywany jest algorytm zależny od ilości pokolorowanych sąsiadów (im więcej tym większy priorytet).
/// </summary>
/// <param name="graph">Graf reprezentowany przez liczbę wszystkich wierzchołków</param>
/// <returns>Pokolorowane wierzchołki oraz 1 jeśli wszystkie wierzchołki zostały pomalowane. 0 jeśli jakiś jest niepomalowany.</returns>
public static void NeighborCountColorsCountColoredNeibour(List <Vertex> graph)
{
Vertex vertex = null;
var sortedByNeighbourCount = graph.OrderByDescending(x => x.Neighbors.Count).ToList();
// koloruje wszystkie wierzchołki
for (int i = 0; i < graph.Count; i++)
{
vertex = sortedByNeighbourCount[i];
if (vertex.Color != 0)
{
continue;
}
var verticesInTie = new List <Vertex>();
// szukam wierzchołki w remisie
for (int j = i + 1; j < graph.Count; j++)
{
if (vertex.Neighbors.Count == sortedByNeighbourCount[j].Neighbors.Count)
{
if (sortedByNeighbourCount[j].Color == 0)
{
verticesInTie.Add(sortedByNeighbourCount[j]);
}
}
else
{
break;
}
}
// jesli nie ma remisu, to maluj i spojrz na kolejny wierzcholek
if (verticesInTie.Count == 0)
{
PaintHelper.PaintVertex(vertex);
continue;
}
// jesli byl remis to dodaj tez ten wierzcholek
verticesInTie.Add(vertex);
var coloredVertex = ColorByDiffColorsInNeighborhood(verticesInTie);
// jesli wierzcholek pomalowany
if (coloredVertex != null)
{
// jesli pomalowany wierzcholek to inny wierzcholek niz ogladany i-ty wierzcholek, to trzeba obejrzec go jeszcze raz
if (coloredVertex != vertex)
{
i--;
}
continue;
}
coloredVertex = ColorByColoredNeighborCount(verticesInTie);
// jesli wierzcholek pomalowany
if (coloredVertex != null)
{
// jesli pomalowany wierzcholek to inny wierzcholek niz ogladany i-ty wierzcholek, to trzeba obejrzec go jeszcze raz
if (coloredVertex != vertex)
{
i--;
}
continue;
}
PaintHelper.PaintVertex(vertex);
}
}