public static void BFS(DrawingSurface ds, int start)
{
var adjList = ds.GetAdjList();
var que = new Queue <int>();
bool[] visited = new bool[ds.Vertices.Count];
que.Enqueue(start - 1);
visited[start - 1] = true;
while (que.Count > 0)
{
start = que.Dequeue();
ReDrawCircle(ds, start, activeVertex, 700);
foreach (var vertex in adjList[start])
{
if (!visited[vertex])
{
ReDrawCircle(ds, vertex, processedVertex, 700);
que.Enqueue(vertex);
visited[vertex] = true;
}
}
ReDrawCircle(ds, start, processedVertex, 700);
}
ClearVertices(ds);
}
private static int[] TopologicalSort(DrawingSurface ds)
{
var visited = new HashSet <int>();
var answer = new int[ds.Vertices.Count];
Dictionary <int, List <int> > adjList = ds.GetAdjList();
var currentPlace = ds.Vertices.Count;
for (var vertex = 0; vertex < ds.Vertices.Count; ++vertex)
{
if (!visited.Contains(vertex))
{
DFS(vertex);
}
}
void DFS(int start)
{
visited.Add(start);
foreach (var vertex in adjList[start])
{
if (!visited.Contains(vertex))
{
DFS(vertex);
}
}
answer[--currentPlace] = start;
}
return(answer);
}
public static void Colouring(DrawingSurface ds)
{
if (!ds.IsUndirected())
{
var err = new ErrorBox("Graph has to be unoriented");
err.ShowDialog();
return;
}
var rnd = new Random {
};
var adjList = ds.GetAdjList();
List <int> nodePowers = ds.GetNodePowers();
List <int> vertices = Enumerable.Range(0, ds.Vertices.Count).OrderByDescending(u => nodePowers[u]).ToList();
List <int> colors_list = Enumerable.Repeat(-1, ds.Vertices.Count).ToList();
int colors_used = 1;
colors = colors.OrderBy(x => rnd.Next()).ToArray();
colors_list[vertices[0]] = 0;
foreach (var vertex in vertices)
{
if (vertex == vertices[0])
{
continue;
}
var adjacentColors = new HashSet <int> {
};
foreach (var adjvertices in adjList[vertex])
{
if (colors_list[adjvertices] != -1)
{
adjacentColors.Add(colors_list[adjvertices]);
}
}
HashSet <int> possibleColors = colors_list.Where(u => u != -1).Except(adjacentColors).ToHashSet();
if (possibleColors.Count == 0)
{
colors_used += 1;
colors_list[vertex] = colors_used - 1;
}
else
{
if (colors_list[vertex] == -1)
{
colors_list[vertex] = possibleColors.Min();
}
}
}
foreach (var vertex in vertices)
{
ReDrawCircle(ds, vertex, colors[colors_list[vertex]]);
}
Thread.Sleep(5000);
ClearVertices(ds);
}
public static void KuhnMatching(DrawingSurface ds)
{
Dictionary <int, List <int> > adjMatrix = ds.GetAdjList();
var maxMatchingColor = Color.Yellow;
var used = new List <bool>();
List <int> matching = Enumerable.Repeat(-1, ds.Vertices.Count).ToList();
bool dfs(int vertex)
{
if (used[vertex])
{
return(false);
}
used[vertex] = true;
foreach (var to in adjMatrix[vertex])
{
if (matching[to] == -1 || (dfs(matching[to])))
{
matching[to] = vertex;
return(true);
}
}
return(false);
}
for (var i = 0; i < ds.Vertices.Count; ++i)
{
for (var j = 0; j < ds.Vertices.Count; ++j)
{
used.Add(false);
}
dfs(i);
}
for (var i = 0; i < ds.Vertices.Count; ++i)
{
if (matching[i] != 1)
{
for (var k = 0; k < ds.Edges.Count; ++k)
{
if (((ds.Edges[k].start == i && ds.Edges[k].end == matching[i]) ||
(ds.Edges[k].start == matching[i] && ds.Edges[k].end == i)))
{
ds.Edges[k].fillColor = maxMatchingColor;
ds.Vertices[ds.Edges[k].start].fillColor = maxMatchingColor;
ds.Vertices[ds.Edges[k].end].fillColor = maxMatchingColor;
ds.Invalidate();
Thread.Sleep(2000);
}
}
}
}
Thread.Sleep(5000);
ClearEdges(ds, false);
ClearVertices(ds);
}
public static void DFS(DrawingSurface ds, int start)
{
Stack <int> stack = new Stack <int>();
stack.Push(start - 1);
var adjList = ds.GetAdjList();
bool[] visited = new bool[ds.Vertices.Count];
while (stack.Count > 0)
{
var vertex = stack.Peek();
ReDrawCircle(ds, vertex, activeVertex, 700);
if (!visited[vertex])
{
visited[vertex] = true;
ReDrawCircle(ds, vertex, processedVertex, 700);
}
bool remove = true;
foreach (int adjvertex in adjList[vertex])
{
if (!visited[adjvertex])
{
stack.Push(adjvertex);
remove = false;
ReDrawCircle(ds, vertex, processedVertex, 700);
break;
}
}
if (remove)
{
int v = stack.Pop();
ReDrawCircle(ds, v, processedVertex, 700);
}
}
ClearVertices(ds);
}
public static void ConnectedComponents(DrawingSurface ds)
{
int[] sortedVertices = TopologicalSort(ds);
var oldGraphEdges = new List <Edge>(ds.Edges);
Dictionary <int, List <int> > adjList = ds.GetAdjList();
var visited = new HashSet <int>();
var component = new List <int>();
var componentsList = new List <List <int> >();
var rnd = new Random(Guid.NewGuid().GetHashCode());
foreach (var edge in ds.Edges)
{
var tmp = edge.start;
edge.setStart(ds.Vertices[edge.end]);
edge.setEnd(ds.Vertices[tmp]);
}
foreach (var vertex in sortedVertices)
{
if (!visited.Contains(vertex))
{
DFS(vertex);
}
if (component.Count != 0)
{
componentsList.Add(new List <int>(component));
component.Clear();
}
}
void DFS(int start)
{
visited.Add(start);
component.Add(start);
foreach (var vertex in adjList[start])
{
if (!visited.Contains(vertex))
{
DFS(vertex);
}
}
}
foreach (var edge in ds.Edges)
{
var tmp = edge.start;
edge.setStart(ds.Vertices[edge.end]);
edge.setEnd(ds.Vertices[tmp]);
}
foreach (var comp in componentsList)
{
var colorForCurrentComponent = Color.FromArgb(255, rnd.Next(255), rnd.Next(255), rnd.Next(255));
foreach (var el in comp)
{
ds.Vertices[el].fillColor = colorForCurrentComponent;
}
for (var i = 0; i < ds.Vertices.Count; ++i)
{
for (var j = 0; j < ds.Vertices.Count; ++j)
{
if (i != j)
{
for (var k = 0; k < ds.Edges.Count; ++k)
{
if (((ds.Edges[k].start == i && ds.Edges[k].end == j) ||
(ds.Edges[k].start == j && ds.Edges[k].end == i)) &&
comp.Contains(i) && comp.Contains(j))
{
ds.Edges[k].fillColor = colorForCurrentComponent;
}
}
}
}
}
ds.Invalidate();
}
Thread.Sleep(5000);
ClearEdges(ds);
ClearVertices(ds);
ds.Invalidate();
}
