public static void Run(Vertex s)
{
s.Color = Color.Gray;
s.Depth = 0;
Queue<Vertex> queue = new Queue<Vertex>();
queue.Enqueue(s);
while(queue.Count > 0)
{
Vertex current = queue.Dequeue();
foreach(Vertex next in current.Vertices)
{
if(next.Color == Color.White)
{
next.Color = Color.Gray;
next.Depth = current.Depth + 1;
next.Parent = current;
queue.Enqueue(next);
}
}
current.Color = Color.Black;
}
}
public static bool Run(Vertex[] vertices, int source)
{
vertices[source].Depth = 0;
for (int i = 0; i < vertices.Length; i++)
{
foreach(Vertex v in vertices)
{
foreach(Edge e in v.Edges)
{
if(e.From.Depth != int.MaxValue && e.From.Depth + e.Weight < e.To.Depth)
{
e.To.Depth = e.From.Depth + e.Weight;
e.To.Parent = e.From;
}
}
}
}
foreach (Vertex v in vertices)
{
foreach (Edge e in v.Edges)
{
if(e.From.Depth + e.Weight < e.To.Depth)
return false;
}
}
return true;
}
public static Edge[] Run(Vertex[] vertices)
{
Dictionary<Vertex, List<Vertex>> sets = new Dictionary<Vertex, List<Vertex>>();
foreach(Vertex v in vertices)
{
sets[v] = new List<Vertex>();
sets[v].Add(v);
}
List<Edge> results = new List<Edge>();
foreach(Edge edge in vertices.SelectMany(v => v.Edges).OrderBy(e => e.Weight))
{
List<Vertex> from = sets[edge.From];
List<Vertex> to = sets[edge.To];
if(from != to)
{
results.Add(edge);
foreach(Vertex v in to)
{
from.Add(v);
sets[v] = from;
}
}
}
return results.ToArray();
}
private static void RemoveRandomEdge(Vertex[] vertices)
{
bool found = false;
int i = 0;
int j = 0;
int count = 0;
Random random = new Random();
for (int k = 0; k < vertices.Length; k++)
{
for (int l = 0; l < vertices.Length; l++)
{
count++;
if (random.Next(0, count) == 0)
{
found = true;
i = k;
j = l;
}
}
}
if (found)
vertices[i].RemoveDirectedEdge(vertices[j]);
}
private static bool IsDirectedAcyclicGraph(Vertex[] vertices)
{
foreach (Vertex v in vertices)
v.Reset();
return !vertices.Any(v => TopologicalSortTestClass.HasCycle(v));
}
public static Vertex[] Run(Vertex[] vertices)
{
List<Vertex> list = new List<Vertex>();
foreach(Vertex v in vertices)
TopologicalSort.Run(v, list);
return list.ToArray();
}
private static bool HasCycle(Vertex vertex)
{
if (vertex.Color == Color.Gray)
return true;
if (vertex.Color == Color.Black)
return false;
vertex.Color = Color.Gray;
if (vertex.Vertices.Any(v => TopologicalSortTestClass.HasCycle(v)))
return true;
vertex.Color = Color.Black;
return false;
}
public static void Run(Vertex s)
{
if (s.Color != Color.White)
return;
s.Color = Color.Gray;
foreach (Vertex next in s.Vertices)
{
if (next.Color == Color.White)
{
next.Parent = s;
DepthFirstSearch.Run(next);
}
}
s.Color = Color.Black;
}
private static void Run(Vertex vertex, List<Vertex> list)
{
if (vertex.Color != Color.White)
return;
vertex.Color = Color.Gray;
foreach(Vertex next in vertex.Vertices)
{
if(next.Color == Color.White)
{
next.Parent = vertex;
TopologicalSort.Run(next, list);
}
}
vertex.Color = Color.Black;
list.Insert(0, vertex);
}
public static void Run(Vertex vertex)
{
vertex.Depth = 0;
PriorityQueue<Vertex> queue = new PriorityQueue<Vertex>((x, y) => y.Depth.CompareTo(x.Depth));
queue.Insert(vertex);
while(!queue.IsEmpty)
{
Vertex current = queue.Pop();
foreach(Edge edge in current.Edges)
{
if(edge.From.Depth + edge.Weight < edge.To.Depth)
{
edge.To.Depth = edge.From.Depth + edge.Weight;
edge.To.Parent = edge.From;
queue.Insert(edge.To);
}
}
}
}
private static Vertex[] CreateDirectedAcyclicGraph(int n)
{
Vertex[] vertices = new Vertex[n];
for (int i = 0; i < vertices.Length; i++)
vertices[i] = new Vertex();
for(int i = 0; i < vertices.Length; i++)
{
for (int j = 0; j < i; j++)
vertices[i].AddUnDirectedEdge(vertices[j]);
}
while (!TopologicalSortTestClass.IsDirectedAcyclicGraph(vertices))
TopologicalSortTestClass.RemoveRandomEdge(vertices);
foreach (Vertex v in vertices)
v.Reset();
return vertices;
}
public static int[,] Run(Vertex[] vertices)
{
int[,] depths = new int[vertices.Length, vertices.Length];
for (int i = 0; i < depths.GetLength(0); i++)
{
for (int j = 0; j < depths.GetLength(1); j++)
{
if(i != j)
depths[i, j] = int.MaxValue;
}
}
for(int i = 0; i < vertices.Length; i++)
{
foreach(Edge edge in vertices[i].Edges)
{
int j = 0;
while (j < vertices.Length && vertices[j] != edge.To)
j++;
depths[i, j] = edge.Weight;
}
}
for (int i = 0; i < vertices.Length; i++)
{
for (int j = 0; j < vertices.Length; j++)
{
for (int k = 0; k < vertices.Length; k++)
{
if(depths[j, i] != int.MaxValue && depths[i, k] != int.MaxValue)
depths[j, k] = Math.Min(depths[j, k], depths[j, i] + depths[i, k]);
}
}
}
return depths;
}
public Edge(Vertex from, Vertex to, int weight)
{
this.From = from;
this.To = to;
this.Weight = weight;
}
public void RemoveUndirectedEdge(Vertex to)
{
this.RemoveDirectedEdge(to);
to.RemoveDirectedEdge(this);
}
public void RemoveDirectedEdge(Vertex to)
{
Edge edge = this.Edges.FirstOrDefault(e => e.To == to);
if (edge != null)
edges.Remove(edge);
}
public void AddUnDirectedEdge(Vertex to, int weight = 1)
{
this.AddDirectedEdge(to, weight);
to.AddDirectedEdge(this, weight);
}
public void AddDirectedEdge(Vertex to, int weight = 1)
{
this.edges.Add(new Edge(this, to, weight));
}
