public static void PerformUndirectedGraphOps()
{
var undirectedGraph = new UndirectedGraph();
undirectedGraph.AddNode("A");
undirectedGraph.AddNode("B");
undirectedGraph.AddNode("C");
undirectedGraph.AddEdge("A", "B", 3);
undirectedGraph.AddEdge("A", "C", 2);
undirectedGraph.Print();
Console.WriteLine("Dijkstra Start");
var dijkstraDemo = new UndirectedGraph();
dijkstraDemo.AddNode("A");
dijkstraDemo.AddNode("B");
dijkstraDemo.AddNode("C");
dijkstraDemo.AddNode("D");
dijkstraDemo.AddNode("E");
dijkstraDemo.AddEdge("A", "B", 3);
dijkstraDemo.AddEdge("A", "C", 4);
dijkstraDemo.AddEdge("A", "D", 2);
dijkstraDemo.AddEdge("B", "D", 6);
dijkstraDemo.AddEdge("B", "E", 1);
dijkstraDemo.AddEdge("C", "D", 1);
dijkstraDemo.AddEdge("D", "E", 5);
dijkstraDemo.Print();
Console.WriteLine("Shortest Path from A to E is : " + dijkstraDemo.GetShortestDistance("A", "E"));
Console.WriteLine("Cycle Detection");
var cycleDetectionDemo = new UndirectedGraph();
cycleDetectionDemo.AddNode("A");
cycleDetectionDemo.AddNode("B");
cycleDetectionDemo.AddNode("C");
cycleDetectionDemo.AddNode("D");
cycleDetectionDemo.AddEdge("A", "B", 1);
cycleDetectionDemo.AddEdge("B", "C", 1);
cycleDetectionDemo.AddEdge("C", "A", 2);
cycleDetectionDemo.Print();
Console.WriteLine("The graph contains cycle : " + cycleDetectionDemo.HasCycles());
Console.WriteLine("Prim's Algorithm for Minimum Spanning Tree");
var primDemo = new UndirectedGraph();
primDemo.AddNode("A");
primDemo.AddNode("B");
primDemo.AddNode("C");
primDemo.AddNode("D");
primDemo.AddEdge("A", "B", 3);
primDemo.AddEdge("A", "C", 1);
primDemo.AddEdge("B", "C", 2);
primDemo.AddEdge("B", "D", 4);
primDemo.AddEdge("C", "D", 5);
primDemo.Print();
Console.WriteLine("Minimum Spanning Tree is : ");
primDemo.FindMinimumSpanningTree().Print();
}
public void When_EdgeIsDuplicated_ExceptionIsThrown()
{
var from = new Node("someValue");
var to = new Node("someOtherValue");
var graph = new UndirectedGraph();
graph.AddNode(from);
graph.AddNode(to);
graph.AddEdge(from, to, 5);
graph.AddEdge(from, to, 5);
}
public void AddTest()
{
UndirectedGraph <string> graph = new UndirectedGraph <string>();
graph.AddNode(new GraphNode <string>("node1"));
graph.AddNode(new GraphNode <string>("node2"));
graph.AddNode(new GraphNode <string>("node3"));
graph.AddNode(new GraphNode <string>("node4"));
graph.AddNode(new GraphNode <string>("node5"));
Assert.IsTrue(graph.Contains("node4"));
Assert.AreEqual(5, graph.Size);
Assert.IsFalse(graph.Contains("dylan"));
}
public void When_EdgeIsAdded_ToNodeBecomesNeighborOfFromNodeAndViceversa()
{
var from = new Node("someValue");
var to = new Node("someOtherValue");
var graph = new UndirectedGraph();
graph.AddNode(from);
graph.AddNode(to);
graph.AddEdge(from, to, 5);
Assert.IsTrue(from.HasNeighbor(to));
Assert.AreEqual(5, from.GetCostTo(to));
Assert.IsTrue(to.HasNeighbor(from));
Assert.AreEqual(5, to.GetCostTo(from));
}
public void AddNodeTestInvalid()
{
// Arrange
Graph testGraph = new UndirectedGraph();
testGraph.AddNode(1, new UndirectedGraph.Node(1, "spin"));
var expectedId = 1;
var expectedPayload = "spin";
// Act
testGraph.AddNode(1, new UndirectedGraph.Node(1, "spot"));
var actual = testGraph.GetNode(1);
// Assert
Assert.AreEqual(expectedId, actual.id);
Assert.AreEqual(expectedPayload, actual.payload);
}
public AbstractGraph <int, int> GetGraph()
{
//Read no of nodes and edges
var graph = new UndirectedGraph <int, int>();
var noOfNodesAndEdges =
Console.ReadLine().Split(separator, StringSplitOptions.RemoveEmptyEntries).Select(int.Parse).ToList();
var noOfNodes = noOfNodesAndEdges.First();
var noOfEdges = noOfNodesAndEdges.Last();
for (int n = 0, e = 0; n < noOfNodes && e < noOfEdges;)
{
var nodeOrEdge =
Console.ReadLine()
.Split(separator, StringSplitOptions.RemoveEmptyEntries)
.Select(int.Parse)
.ToList();
//Node only
if (nodeOrEdge.Count == 1)
{
graph.AddNode(nodeOrEdge.First());
n++;
}
//Edge without weight
else if (nodeOrEdge.Count == 2)
{
e++;
AddEdge(graph, nodeOrEdge[0], nodeOrEdge[1], DefaultEdgeWeight);
}
//edge with weight
else
{
e++;
AddEdge(graph, nodeOrEdge[0], nodeOrEdge[1], nodeOrEdge[2]);
}
}
for (var n = 1; n <= noOfNodes; n++)
{
if (!graph.GetNodes().Contains(n))
{
graph.AddNode(n);
}
}
return(graph);
}
public void When_EdgeToANonExistingNodeInGraphIsAdded_ExceptionIsThrown()
{
var from = new Node("someValue");
var to = new Node("someOtherValue");
var graph = new UndirectedGraph();
graph.AddNode(from);
graph.AddEdge(from, to, 1);
}
// Generates a new undirected graph using an adjacency matrix.
public UndirectedGraph <int> GenerateUndirectedGraph(int size, float probability)
{
UndirectedGraph <int> graph = new UndirectedGraph <int>(size);
System.Random rPos = new System.Random();
int[,] adjMat = GenerateAdjacencyMatrix(size, probability);
for (int x = 0; x < size; x++)
{
if (x == 0)
{
graph.AddNode(new EntryNode(x, Vector3.zero));
}
else if (x == size - 2)
{
graph.AddNode(new BossRoom(x, new Vector3(rPos.Next(x - 3, x + 3) * scale, 0, rPos.Next(x - 3, x + 3) * scale)));
}
else if (x == size - 1)
{
graph.AddNode(new ExitNode(x, new Vector3(rPos.Next(x - 3, x + 3) * scale, 0, rPos.Next(x - 3, x + 3) * scale)));
}
else
{
graph.AddNode(new RoomNode(x, new Vector3(rPos.Next(x - 3, x + 3) * scale, 0, rPos.Next(x - 3, x + 3) * scale)));
}
}
for (int x = 0; x < size; x++)
{
for (int y = 0; y < size; y++)
{
// int difference = Mathf.Abs(y) + x;
if (adjMat[x, y] == 1 && !graph.Nodes[x].Neighbours.Contains(graph.Nodes[y]))
{
graph.Nodes[x].AddEdge(graph.Nodes[y]);
}
}
}
return(graph);
}
public void GetPathPayloadTestValid()
{
// Arrange
UndirectedGraph testGraph = new UndirectedGraph();
Dictionary <string, string[]> testData = new Dictionary <string, string[]>
{
{ "bird", new string[] { "gird", "bard", "byrd", "bind" } },
{ "gird", new string[] { "bird", "gild", "girl", "girt" } },
{ "bard", new string[] { "card", "hard", "lard", "ward", "yard", "bird", "byrd", "bald", "band", "baud", "bawd", "barb", "bare", "bark", "barn", "barr", "bart" } },
{ "byrd", new string[] { "bard", "bird" } },
{ "bind", new string[] { "find", "hind", "kind", "lind", "mind", "wind", "band", "bend", "bond", "bird", "bing", "bini" } },
{ "wind", new string[] { "bind", "find", "hind", "kind", "lind", "mind", "wand", "wild", "wine", "wing", "wink", "wino", "winy" } },
{ "wing", new string[] { "bing", "ding", "king", "ping", "ring", "sing", "zing", "wang", "wong", "wind", "wine", "wink", "wino", "winy" } },
};
int nodeId = 1;
foreach (string word in testData.Keys)
{
testGraph.AddNode(nodeId, new UndirectedGraph.Node(nodeId, word));
nodeId++;
}
foreach (var node in testData)
{
foreach (string neighbour in node.Value)
{
if (!testData.ContainsKey(neighbour))
{
continue;
}
else
{
testGraph.AddEdge(testGraph.GetNodeId(node.Key), testGraph.GetNodeId(neighbour));
}
}
}
var expected = new List <string> {
"bird", "bind", "wind", "wing"
};
// Act
var actual = testGraph.HasPathBFS(testGraph.GetNode(testGraph.GetNodeId("bird")), testGraph.GetNode(testGraph.GetNodeId("wing")));
// Assert
Assert.IsTrue(actual.Item1);
Assert.IsTrue(expected.Count == actual.Item2.Count);
for (int i = 0; i < expected.Count; i++)
{
Assert.AreEqual(expected[i], actual.Item2[i]);
}
}
public void When_NodeIsRemovedFromGraph_GraphNodesDoNotContainRemovedNode()
{
var node = new Node("someValue");
var graph = new UndirectedGraph();
graph.AddNode(node);
graph.RemoveNode(node);
Assert.IsFalse(graph.HasNode(node));
Assert.AreEqual(0, graph.GetCount());
}
public void When_NodeIsRemovedFromGraph_AllEdgesToTheRemovedNodeAreCleared()
{
var from = new Node("someValue");
var to = new Node("someOtherValue");
var to2 = new Node("anotherValue");
var graph = new UndirectedGraph();
graph.AddNode(from);
graph.AddNode(to);
graph.AddNode(to2);
graph.AddEdge(from, to, 5);
graph.AddEdge(from, to2, 6);
graph.RemoveNode(from);
foreach (Node node in graph.GetNodes())
{
Assert.IsFalse(node.HasNeighbor(from));
}
Assert.IsFalse(graph.HasNode(from));
}
public void GetNodePayloadTestValid()
{
// Arrange
UndirectedGraph testGraph = new UndirectedGraph();
testGraph.AddNode(1, new UndirectedGraph.Node(1, "spin"));
string expectedPayload = "spin";
// Act
var actual = testGraph.GetNodePayload(1);
// Assert
Assert.AreEqual(expectedPayload, actual);
}
public void GetNodeTestInvalid()
{
// Arrange
UndirectedGraph testGraph = new UndirectedGraph();
testGraph.AddNode(1, new UndirectedGraph.Node(1, "spin"));
UndirectedGraph.Node expected = null;
// Act
var actual = testGraph.GetNode(2);
// Assert
Assert.AreEqual(expected, actual);
}
public void GetNodeIdTestValid()
{
// Arrange
UndirectedGraph testGraph = new UndirectedGraph();
testGraph.AddNode(1, new UndirectedGraph.Node(1, "spin"));
int expectedId = 1;
// Act
var actual = testGraph.GetNodeId("spin");
// Assert
Assert.AreEqual(expectedId, actual);
}
public static PandemicBoard FromCitiesAndEdges(IEnumerable <City> cities, IEnumerable <Edge> edges)
{
var cityGraph = new UndirectedGraph <City>();
foreach (var city in cities)
{
cityGraph.AddNode(city);
}
foreach (var edge in edges)
{
cityGraph.AddEdge(edge.From, edge.To);
}
return(new PandemicBoard(cityGraph));
}
public void When_UndirectedGraphIsComplex_MinimumPathIsReturned()
{
//testing graph example from https://msdn.microsoft.com/en-US/library/ms379574(v=vs.80).aspx
var newYork = new Node("New York");
var chicago = new Node("Chicago");
var sanFrancisco = new Node("San Francisco");
var denver = new Node("Denver");
var losAngeles = new Node("Los Angeles");
var dallas = new Node("Dallas");
var miami = new Node("Miami");
var sanDiego = new Node("San Diego");
var graph = new UndirectedGraph();
graph.AddNode(newYork);
graph.AddNode(chicago);
graph.AddNode(sanFrancisco);
graph.AddNode(denver);
graph.AddNode(losAngeles);
graph.AddNode(dallas);
graph.AddNode(miami);
graph.AddNode(sanDiego);
graph.AddEdge(newYork, chicago, 75);
graph.AddEdge(newYork, denver, 100);
graph.AddEdge(newYork, dallas, 125);
graph.AddEdge(newYork, miami, 90);
graph.AddEdge(chicago, sanFrancisco, 25);
graph.AddEdge(chicago, denver, 20);
graph.AddEdge(sanFrancisco, losAngeles, 45);
graph.AddEdge(sanDiego, losAngeles, 45);
graph.AddEdge(dallas, sanDiego, 90);
graph.AddEdge(dallas, losAngeles, 80);
graph.AddEdge(miami, dallas, 50);
graph.AddEdge(denver, losAngeles, 100);
var dijkstra = new Dijkstra(graph);
List <Node> minimumPath = dijkstra.GetMinimumPathBetween(newYork, losAngeles).ToList();
var expectedPath = new List <Node> {
newYork, chicago, sanFrancisco, losAngeles
};
CollectionAssert.AreEqual(expectedPath, minimumPath);
Assert.AreEqual(145, dijkstra.GetPathCost(minimumPath));
}
public void ShouldAddNodes(string inodes)
{
//Arrange
var expectedNodes =
inodes.Split(nodeSeparator, StringSplitOptions.RemoveEmptyEntries)
.Select(char.Parse)
.OrderBy(x => x)
.ToList();
AbstractGraph <char, int> sut = new UndirectedGraph <char, int>();
//Act
expectedNodes.ForEach(x => sut.AddNode(x));
var actual = sut.GetNodes().OrderBy(x => x);
//Assert
Assert.AreEqual(expectedNodes, actual);
}
public static UndirectedGraph <City> LoadCityGraph()
{
var graph = new UndirectedGraph <City>();
var idxLookup = BuildCityIdxLookup(Cities);
foreach (var city in Cities)
{
graph.AddNode(city);
}
foreach (var(cityFrom, cityTo) in Edges)
{
graph.AddEdge(idxLookup[cityFrom], idxLookup[cityTo]);
}
return(graph);
}
public void ShouldAddNodes(string inodes)
{
//Arrange
var expectedNodes =
inodes.Split(nodeSeparator, StringSplitOptions.RemoveEmptyEntries)
.Select(char.Parse)
.OrderBy(x => x)
.ToList();
AbstractGraph<char, int> sut = new UndirectedGraph<char, int>();
//Act
expectedNodes.ForEach(x => sut.AddNode(x));
var actual = sut.GetNodes().OrderBy(x => x);
//Assert
Assert.AreEqual(expectedNodes, actual);
}
private AbstractGraph <int, int> GetMockGraph(string igraph, int edgeWeight)
{
var edges = igraph.Split(_edgeSeparator, StringSplitOptions.RemoveEmptyEntries);
var graph = new UndirectedGraph <int, int>();
foreach (var edge in edges)
{
var nodesConnectingEdge =
edge.Split(_nodeSeparator, StringSplitOptions.RemoveEmptyEntries).Select(int.Parse).ToList();
if (nodesConnectingEdge.Count == 1)
{
graph.AddNode(nodesConnectingEdge.Single());
}
else
{
graph.AddEdge(nodesConnectingEdge.First(), nodesConnectingEdge.Last(), edgeWeight);
}
}
return(graph);
//var mockGraph = MockRepository.GenerateStub<AbstractGraph<int, int>>();
//var nodes = new List<int>();
//foreach (var edge in edges)
//{
// var nodesConnectingEdge = edge.Split(nodeSeparator).Select(int.Parse).ToList();
// if (nodes.Contains(nodesConnectingEdge.First()))
// {
// nodes.Add(nodesConnectingEdge.First());
// }
// if (nodes.Contains(nodesConnectingEdge.Last()))
// {
// nodes.Add(nodesConnectingEdge.Last());
// }
//}
//mockGraph.Stub(x => x.GetNodes()).Return(nodes);
//// mockGraph.Stub(x=>x.GetNeighbours(1)).IgnoreArguments().Do()
//return mockGraph;
}
public void Chordal()
{
var graph = new UndirectedGraph <char, EdgeData>();
graph.AddNodes('a', 'b', 'c', 'd', 'e');
graph.AddEdges(
('a', 'b', dummyEdgeData),
('a', 'c', dummyEdgeData),
('b', 'c', dummyEdgeData),
('b', 'd', dummyEdgeData),
('b', 'e', dummyEdgeData),
('c', 'd', dummyEdgeData),
('d', 'e', dummyEdgeData)
);
graph.Chordal.Should().BeTrue();
graph.AddNode('f');
graph.AddEdge('a', 'f', dummyEdgeData);
graph.Chordal.Should().BeFalse();
}
private AbstractGraph<int, int> GetMockGraph(string igraph, int edgeWeight)
{
var edges = igraph.Split(_edgeSeparator, StringSplitOptions.RemoveEmptyEntries);
var graph = new UndirectedGraph<int, int>();
foreach (var edge in edges)
{
var nodesConnectingEdge =
edge.Split(_nodeSeparator, StringSplitOptions.RemoveEmptyEntries).Select(int.Parse).ToList();
if (nodesConnectingEdge.Count == 1)
{
graph.AddNode(nodesConnectingEdge.Single());
}
else
{
graph.AddEdge(nodesConnectingEdge.First(), nodesConnectingEdge.Last(), edgeWeight);
}
}
return graph;
//var mockGraph = MockRepository.GenerateStub<AbstractGraph<int, int>>();
//var nodes = new List<int>();
//foreach (var edge in edges)
//{
// var nodesConnectingEdge = edge.Split(nodeSeparator).Select(int.Parse).ToList();
// if (nodes.Contains(nodesConnectingEdge.First()))
// {
// nodes.Add(nodesConnectingEdge.First());
// }
// if (nodes.Contains(nodesConnectingEdge.Last()))
// {
// nodes.Add(nodesConnectingEdge.Last());
// }
//}
//mockGraph.Stub(x => x.GetNodes()).Return(nodes);
//// mockGraph.Stub(x=>x.GetNeighbours(1)).IgnoreArguments().Do()
//return mockGraph;
}
public void GivenASingleEdgeIsAdded_ShouldHaveOneEdge()
{
// arrange
_graph.AddNode(0);
_graph.AddNode(0);
// act
_graph.AddEdge(0, 1);
// assert
var edgesFrom0 = _graph.GetEdgesFrom(0);
var edgesFrom1 = _graph.GetEdgesFrom(1);
Assert.AreEqual(1, edgesFrom0.Count);
Assert.AreEqual(0, edgesFrom0.Single().From);
Assert.AreEqual(1, edgesFrom0.Single().To);
Assert.AreEqual(1, edgesFrom1.Count);
Assert.AreEqual(1, edgesFrom1.Single().From);
Assert.AreEqual(0, edgesFrom1.Single().To);
}
