public static void DoTest()
{
// The graph
IGraph <string> graph = new UndirectedSparseGraph <string>();
// The bipartite wrapper
BipartiteColoring <UndirectedSparseGraph <string>, string> bipartiteGraph;
// The status for checking bipartiteness
bool initBipartiteStatus;
// Prepare the graph for the first case of testing
_initializeFirstCaseGraph(ref graph);
// Test initializing the bipartite
// This initialization must fail. The graph contains an odd cycle
initBipartiteStatus = false;
bipartiteGraph = null;
try
{
bipartiteGraph = new BipartiteColoring <UndirectedSparseGraph <string>, string>(graph);
initBipartiteStatus = bipartiteGraph.IsBipartite();
}
catch
{
initBipartiteStatus = false;
}
Debug.Assert(initBipartiteStatus == false, "Graph should not be bipartite.");
/************************************************************/
//
// Prepare the graph for the second case of testing
_initializeSecondCaseGraph(ref graph);
//
// Test initializing the bipartite
// This initialization must fail. The graph contains an odd cycle
bipartiteGraph = null;
initBipartiteStatus = false;
try
{
bipartiteGraph = new BipartiteColoring <UndirectedSparseGraph <string>, string>(graph);
initBipartiteStatus = bipartiteGraph.IsBipartite();
}
catch
{
initBipartiteStatus = false;
}
Debug.Assert(initBipartiteStatus == false, "Graph should not be bipartite.");
//
// Remove Odd Cycle and try to initialize again.
initBipartiteStatus = true;
graph.RemoveEdge("c", "v");
graph.RemoveEdge("f", "b");
//
// This initialization must pass. The graph doesn't contain any odd cycle
try
{
bipartiteGraph = new BipartiteColoring <UndirectedSparseGraph <string>, string>(graph);
initBipartiteStatus = bipartiteGraph.IsBipartite();
}
catch
{
initBipartiteStatus = false;
}
Debug.Assert(initBipartiteStatus == true, "Graph should be bipartite.");
Debug.Assert(bipartiteGraph.ColorOf("a") == BipartiteColor.Red);
Debug.Assert(bipartiteGraph.ColorOf("s") == BipartiteColor.Blue);
Debug.Assert(bipartiteGraph.ColorOf("b") == BipartiteColor.Red);
Debug.Assert(bipartiteGraph.ColorOf("f") == BipartiteColor.Red);
Debug.Assert(bipartiteGraph.ColorOf("z") == BipartiteColor.Blue);
}
public static void DoTest()
{
var graph = new UndirectedSparseGraph <string>();
var verticesSet1 = new string[] { "a", "z", "s", "x", "d", "c", "f", "v" };
graph.AddVertices(verticesSet1);
graph.AddEdge("a", "s");
graph.AddEdge("a", "z");
graph.AddEdge("s", "x");
graph.AddEdge("x", "d");
graph.AddEdge("x", "c");
graph.AddEdge("d", "f");
graph.AddEdge("d", "c");
graph.AddEdge("c", "f");
graph.AddEdge("c", "v");
graph.AddEdge("v", "f");
var allEdges = graph.Edges.ToList();
Assert.True(graph.VerticesCount == 8, "Wrong vertices count.");
Assert.True(graph.EdgesCount == 10, "Wrong edges count.");
Assert.True(graph.EdgesCount == allEdges.Count, "Wrong edges count.");
Assert.True(graph.OutgoingEdges("a").ToList().Count == 2, "Wrong outgoing edges from 'a'.");
Assert.True(graph.OutgoingEdges("s").ToList().Count == 2, "Wrong outgoing edges from 's'.");
Assert.True(graph.OutgoingEdges("x").ToList().Count == 3, "Wrong outgoing edges from 'x'.");
Assert.True(graph.OutgoingEdges("d").ToList().Count == 3, "Wrong outgoing edges from 'd'.");
Assert.True(graph.OutgoingEdges("c").ToList().Count == 4, "Wrong outgoing edges from 'c'.");
Assert.True(graph.OutgoingEdges("v").ToList().Count == 2, "Wrong outgoing edges from 'v'.");
Assert.True(graph.OutgoingEdges("f").ToList().Count == 3, "Wrong outgoing edges from 'f'.");
Assert.True(graph.OutgoingEdges("z").ToList().Count == 1, "Wrong outgoing edges from 'z'.");
Assert.True(graph.IncomingEdges("a").ToList().Count == 2, "Wrong incoming edges from 'a'.");
Assert.True(graph.IncomingEdges("s").ToList().Count == 2, "Wrong incoming edges from 's'.");
Assert.True(graph.IncomingEdges("x").ToList().Count == 3, "Wrong incoming edges from 'x'.");
Assert.True(graph.IncomingEdges("d").ToList().Count == 3, "Wrong incoming edges from 'd'.");
Assert.True(graph.IncomingEdges("c").ToList().Count == 4, "Wrong incoming edges from 'c'.");
Assert.True(graph.IncomingEdges("v").ToList().Count == 2, "Wrong incoming edges from 'v'.");
Assert.True(graph.IncomingEdges("f").ToList().Count == 3, "Wrong incoming edges from 'f'.");
Assert.True(graph.IncomingEdges("z").ToList().Count == 1, "Wrong incoming edges from 'z'.");
graph.RemoveEdge("d", "c");
graph.RemoveEdge("c", "v");
graph.RemoveEdge("a", "z");
Assert.True(graph.VerticesCount == 8, "Wrong vertices count.");
Assert.True(graph.EdgesCount == 7, "Wrong edges count.");
graph.RemoveVertex("x");
Assert.True(graph.VerticesCount == 7, "Wrong vertices count.");
Assert.True(graph.EdgesCount == 4, "Wrong edges count.");
graph.AddVertex("x");
graph.AddEdge("s", "x");
graph.AddEdge("x", "d");
graph.AddEdge("x", "c");
graph.AddEdge("d", "c");
graph.AddEdge("c", "v");
graph.AddEdge("a", "z");
Assert.True(graph.BreadthFirstWalk("s").SequenceEqual(new string[] { "s", "a", "x", "z", "d", "c", "f", "v" }));
graph.AddVertices(new string[] { "a", "b", "c", "d", "e", "f" });
graph.AddEdge("a", "b");
graph.AddEdge("a", "d");
graph.AddEdge("b", "e");
graph.AddEdge("d", "b");
graph.AddEdge("d", "e");
graph.AddEdge("e", "c");
graph.AddEdge("c", "f");
graph.AddEdge("f", "f");
Assert.True(graph.VerticesCount == 10, "Wrong vertices count.");
Assert.True(graph.EdgesCount == 17, "Wrong edges count.");
Assert.True(graph.DepthFirstWalk().SequenceEqual(new string[] { "a", "d", "e", "c", "v", "f", "x", "s", "b", "z" }));
}
public static void DoTest()
{
var graph = new UndirectedSparseGraph<string>();
var verticesSet1 = new string[] { "a", "z", "s", "x", "d", "c", "f", "v" };
graph.AddVertices(verticesSet1);
graph.AddEdge("a", "s");
graph.AddEdge("a", "z");
graph.AddEdge("s", "x");
graph.AddEdge("x", "d");
graph.AddEdge("x", "c");
graph.AddEdge("d", "f");
graph.AddEdge("d", "c");
graph.AddEdge("c", "f");
graph.AddEdge("c", "v");
graph.AddEdge("v", "f");
var allEdges = graph.Edges.ToList();
Debug.Assert(graph.VerticesCount == 8, "Wrong vertices count.");
Debug.Assert(graph.EdgesCount == 10, "Wrong edges count.");
Debug.Assert(graph.EdgesCount == allEdges.Count, "Wrong edges count.");
Debug.Assert(graph.OutgoingEdges("a").ToList().Count == 2, "Wrong outgoing edges from 'a'.");
Debug.Assert(graph.OutgoingEdges("s").ToList().Count == 2, "Wrong outgoing edges from 's'.");
Debug.Assert(graph.OutgoingEdges("x").ToList().Count == 3, "Wrong outgoing edges from 'x'.");
Debug.Assert(graph.OutgoingEdges("d").ToList().Count == 3, "Wrong outgoing edges from 'd'.");
Debug.Assert(graph.OutgoingEdges("c").ToList().Count == 4, "Wrong outgoing edges from 'c'.");
Debug.Assert(graph.OutgoingEdges("v").ToList().Count == 2, "Wrong outgoing edges from 'v'.");
Debug.Assert(graph.OutgoingEdges("f").ToList().Count == 3, "Wrong outgoing edges from 'f'.");
Debug.Assert(graph.OutgoingEdges("z").ToList().Count == 1, "Wrong outgoing edges from 'z'.");
Debug.Assert(graph.IncomingEdges("a").ToList().Count == 2, "Wrong incoming edges from 'a'.");
Debug.Assert(graph.IncomingEdges("s").ToList().Count == 2, "Wrong incoming edges from 's'.");
Debug.Assert(graph.IncomingEdges("x").ToList().Count == 3, "Wrong incoming edges from 'x'.");
Debug.Assert(graph.IncomingEdges("d").ToList().Count == 3, "Wrong incoming edges from 'd'.");
Debug.Assert(graph.IncomingEdges("c").ToList().Count == 4, "Wrong incoming edges from 'c'.");
Debug.Assert(graph.IncomingEdges("v").ToList().Count == 2, "Wrong incoming edges from 'v'.");
Debug.Assert(graph.IncomingEdges("f").ToList().Count == 3, "Wrong incoming edges from 'f'.");
Debug.Assert(graph.IncomingEdges("z").ToList().Count == 1, "Wrong incoming edges from 'z'.");
Console.WriteLine("[*] Undirected Sparse Graph:");
Console.WriteLine("Graph nodes and edges:");
Console.WriteLine(graph.ToReadable() + "\r\n");
graph.RemoveEdge("d", "c");
graph.RemoveEdge("c", "v");
graph.RemoveEdge("a", "z");
Debug.Assert(graph.VerticesCount == 8, "Wrong vertices count.");
Debug.Assert(graph.EdgesCount == 7, "Wrong edges count.");
Console.WriteLine("After removing edges (d-c), (c-v), (a-z):");
Console.WriteLine(graph.ToReadable() + "\r\n");
graph.RemoveVertex("x");
Debug.Assert(graph.VerticesCount == 7, "Wrong vertices count.");
Debug.Assert(graph.EdgesCount == 4, "Wrong edges count.");
Console.WriteLine("After removing node (x):");
Console.WriteLine(graph.ToReadable() + "\r\n");
graph.AddVertex("x");
graph.AddEdge("s", "x");
graph.AddEdge("x", "d");
graph.AddEdge("x", "c");
graph.AddEdge("d", "c");
graph.AddEdge("c", "v");
graph.AddEdge("a", "z");
Console.WriteLine("Re-added the deleted vertices and edges to the graph.");
Console.WriteLine(graph.ToReadable() + "\r\n");
Console.WriteLine("Walk the graph using BFS:");
graph.BreadthFirstWalk("s"); // output: (s) (a) (x) (z) (d) (c) (f) (v)
Console.WriteLine("\r\n");
/********************************************************************/
Console.WriteLine("***************************************************\r\n");
graph.Clear();
Console.WriteLine("Cleared the graph from all vertices and edges.\r\n");
var verticesSet2 = new string[] { "a", "b", "c", "d", "e", "f" };
graph.AddVertices(verticesSet2);
graph.AddEdge("a", "b");
graph.AddEdge("a", "d");
graph.AddEdge("b", "e");
graph.AddEdge("d", "b");
graph.AddEdge("d", "e");
graph.AddEdge("e", "c");
graph.AddEdge("c", "f");
graph.AddEdge("f", "f");
Debug.Assert(graph.VerticesCount == 6, "Wrong vertices count.");
Debug.Assert(graph.EdgesCount == 8, "Wrong edges count.");
Console.WriteLine("[*] NEW Undirected Sparse Graph:");
Console.WriteLine("Graph nodes and edges:");
Console.WriteLine(graph.ToReadable() + "\r\n");
Console.WriteLine("Walk the graph using DFS:");
graph.DepthFirstWalk(); // output: (a) (b) (e) (d) (c) (f)
}
public static void DoTest()
{
// The graph
IGraph<string> graph = new UndirectedSparseGraph<string>();
// The bipartite wrapper
BipartiteColoring<UndirectedSparseGraph<string>, string> bipartiteGraph;
// The status for checking bipartiteness
bool initBipartiteStatus;
//
// Prepare the graph for the first case of testing
_initializeFirstCaseGraph(ref graph);
//
// Test initializing the bipartite
// This initialization must fail. The graph contains an odd cycle
initBipartiteStatus = false;
bipartiteGraph = null;
try
{
bipartiteGraph = new BipartiteColoring<UndirectedSparseGraph<string>, string>(graph);
initBipartiteStatus = bipartiteGraph.IsBipartite();
}
catch
{
initBipartiteStatus = false;
}
Debug.Assert(initBipartiteStatus == false, "Graph should not be bipartite.");
/************************************************************/
//
// Prepare the graph for the second case of testing
_initializeSecondCaseGraph(ref graph);
//
// Test initializing the bipartite
// This initialization must fail. The graph contains an odd cycle
bipartiteGraph = null;
initBipartiteStatus = false;
try
{
bipartiteGraph = new BipartiteColoring<UndirectedSparseGraph<string>, string>(graph);
initBipartiteStatus = bipartiteGraph.IsBipartite();
}
catch
{
initBipartiteStatus = false;
}
Debug.Assert(initBipartiteStatus == false, "Graph should not be bipartite.");
//
// Remove Odd Cycle and try to initialize again.
initBipartiteStatus = true;
graph.RemoveEdge("c", "v");
graph.RemoveEdge("f", "b");
//
// This initialization must pass. The graph doesn't contain any odd cycle
try
{
bipartiteGraph = new BipartiteColoring<UndirectedSparseGraph<string>, string>(graph);
initBipartiteStatus = bipartiteGraph.IsBipartite();
}
catch
{
initBipartiteStatus = false;
}
Debug.Assert(initBipartiteStatus == true, "Graph should be bipartite.");
Debug.Assert(bipartiteGraph.ColorOf("a") == BipartiteColor.Red);
Debug.Assert(bipartiteGraph.ColorOf("s") == BipartiteColor.Blue);
Debug.Assert(bipartiteGraph.ColorOf("b") == BipartiteColor.Red);
Debug.Assert(bipartiteGraph.ColorOf("f") == BipartiteColor.Red);
Debug.Assert(bipartiteGraph.ColorOf("z") == BipartiteColor.Blue);
}
public static void DoTest()
{
var graph = new UndirectedSparseGraph <string>();
var verticesSet1 = new string[] { "a", "z", "s", "x", "d", "c", "f", "v" };
graph.AddVertices(verticesSet1);
graph.AddEdge("a", "s");
graph.AddEdge("a", "z");
graph.AddEdge("s", "x");
graph.AddEdge("x", "d");
graph.AddEdge("x", "c");
graph.AddEdge("d", "f");
graph.AddEdge("d", "c");
graph.AddEdge("c", "f");
graph.AddEdge("c", "v");
graph.AddEdge("v", "f");
var allEdges = graph.Edges.ToList();
Debug.Assert(graph.VerticesCount == 8, "Wrong vertices count.");
Debug.Assert(graph.EdgesCount == 10, "Wrong edges count.");
Debug.Assert(graph.EdgesCount == allEdges.Count, "Wrong edges count.");
Debug.Assert(graph.OutgoingEdges("a").ToList().Count == 2, "Wrong outgoing edges from 'a'.");
Debug.Assert(graph.OutgoingEdges("s").ToList().Count == 2, "Wrong outgoing edges from 's'.");
Debug.Assert(graph.OutgoingEdges("x").ToList().Count == 3, "Wrong outgoing edges from 'x'.");
Debug.Assert(graph.OutgoingEdges("d").ToList().Count == 3, "Wrong outgoing edges from 'd'.");
Debug.Assert(graph.OutgoingEdges("c").ToList().Count == 4, "Wrong outgoing edges from 'c'.");
Debug.Assert(graph.OutgoingEdges("v").ToList().Count == 2, "Wrong outgoing edges from 'v'.");
Debug.Assert(graph.OutgoingEdges("f").ToList().Count == 3, "Wrong outgoing edges from 'f'.");
Debug.Assert(graph.OutgoingEdges("z").ToList().Count == 1, "Wrong outgoing edges from 'z'.");
Debug.Assert(graph.IncomingEdges("a").ToList().Count == 2, "Wrong incoming edges from 'a'.");
Debug.Assert(graph.IncomingEdges("s").ToList().Count == 2, "Wrong incoming edges from 's'.");
Debug.Assert(graph.IncomingEdges("x").ToList().Count == 3, "Wrong incoming edges from 'x'.");
Debug.Assert(graph.IncomingEdges("d").ToList().Count == 3, "Wrong incoming edges from 'd'.");
Debug.Assert(graph.IncomingEdges("c").ToList().Count == 4, "Wrong incoming edges from 'c'.");
Debug.Assert(graph.IncomingEdges("v").ToList().Count == 2, "Wrong incoming edges from 'v'.");
Debug.Assert(graph.IncomingEdges("f").ToList().Count == 3, "Wrong incoming edges from 'f'.");
Debug.Assert(graph.IncomingEdges("z").ToList().Count == 1, "Wrong incoming edges from 'z'.");
Console.WriteLine("[*] Undirected Sparse Graph:");
Console.WriteLine("Graph nodes and edges:");
Console.WriteLine(graph.ToReadable() + "\r\n");
graph.RemoveEdge("d", "c");
graph.RemoveEdge("c", "v");
graph.RemoveEdge("a", "z");
Debug.Assert(graph.VerticesCount == 8, "Wrong vertices count.");
Debug.Assert(graph.EdgesCount == 7, "Wrong edges count.");
Console.WriteLine("After removing edges (d-c), (c-v), (a-z):");
Console.WriteLine(graph.ToReadable() + "\r\n");
graph.RemoveVertex("x");
Debug.Assert(graph.VerticesCount == 7, "Wrong vertices count.");
Debug.Assert(graph.EdgesCount == 4, "Wrong edges count.");
Console.WriteLine("After removing node (x):");
Console.WriteLine(graph.ToReadable() + "\r\n");
graph.AddVertex("x");
graph.AddEdge("s", "x");
graph.AddEdge("x", "d");
graph.AddEdge("x", "c");
graph.AddEdge("d", "c");
graph.AddEdge("c", "v");
graph.AddEdge("a", "z");
Console.WriteLine("Re-added the deleted vertices and edges to the graph.");
Console.WriteLine(graph.ToReadable() + "\r\n");
Console.WriteLine("Walk the graph using BFS:");
graph.BreadthFirstWalk("s"); // output: (s) (a) (x) (z) (d) (c) (f) (v)
Console.WriteLine("\r\n");
/********************************************************************/
Console.WriteLine("***************************************************\r\n");
graph.Clear();
Console.WriteLine("Cleared the graph from all vertices and edges.\r\n");
var verticesSet2 = new string[] { "a", "b", "c", "d", "e", "f" };
graph.AddVertices(verticesSet2);
graph.AddEdge("a", "b");
graph.AddEdge("a", "d");
graph.AddEdge("b", "e");
graph.AddEdge("d", "b");
graph.AddEdge("d", "e");
graph.AddEdge("e", "c");
graph.AddEdge("c", "f");
graph.AddEdge("f", "f");
Debug.Assert(graph.VerticesCount == 6, "Wrong vertices count.");
Debug.Assert(graph.EdgesCount == 8, "Wrong edges count.");
Console.WriteLine("[*] NEW Undirected Sparse Graph:");
Console.WriteLine("Graph nodes and edges:");
Console.WriteLine(graph.ToReadable() + "\r\n");
Console.WriteLine("Walk the graph using DFS:");
graph.DepthFirstWalk(); // output: (a) (b) (e) (d) (c) (f)
}
// GET: /<controller>/
public IActionResult Index()
{
string result = string.Empty;
// The graph
IGraph <string> graph = new UndirectedSparseGraph <string>();
// The bipartite wrapper
BipartiteColoring <UndirectedSparseGraph <string>, string> bipartiteGraph;
// The status for checking bipartiteness
bool initBipartiteStatus;
//
// Prepare the graph for the second case of testing
_initializeSecondCaseGraph(ref graph, ref result);
//
// Test initializing the bipartite
// This initialization must fail. The graph contains an odd cycle
bipartiteGraph = null;
initBipartiteStatus = false;
try
{
bipartiteGraph = new BipartiteColoring <UndirectedSparseGraph <string>, string>(graph);
initBipartiteStatus = bipartiteGraph.IsBipartite();
}
catch (Exception ex)
{
string err = ex.Message;
initBipartiteStatus = false;
}
if (!initBipartiteStatus)
{
Console.WriteLine("Graph should not be bipartite.");
}
//
// Remove Odd Cycle and try to initialize again.
initBipartiteStatus = true;
graph.RemoveEdge("c", "v");
graph.RemoveEdge("f", "b");
//
// This initialization must pass. The graph doesn't contain any odd cycle
try
{
bipartiteGraph = new BipartiteColoring <UndirectedSparseGraph <string>, string>(graph);
initBipartiteStatus = bipartiteGraph.IsBipartite();
}
catch
{
initBipartiteStatus = false;
}
if (!initBipartiteStatus)
{
Console.WriteLine("Graph should not be bipartite.");
}
result = result + " 'a' color is " + bipartiteGraph.ColorOf("a") + "\n";
result = result + " 's' color is " + bipartiteGraph.ColorOf("s") + "\n";
result = result + " 'b' color is " + bipartiteGraph.ColorOf("b") + "\n";
result = result + " 'f' color is " + bipartiteGraph.ColorOf("f") + "\n";
result = result + " 'z' color is " + bipartiteGraph.ColorOf("z") + "\n";
HtmlString html = StringHelper.GetHtmlString(result);
return(View(html));
}