public void One_By_One_Grid()
{
var grid = new Grid(1, 1, new long[] {
4
});
var adapter = new GridGraphProxiedAdapter(grid);
var nodes = adapter.GetGraph(0, 0, 0, 0);
var result = TreeTraverser.BrutForceMaxPathDFS(nodes.startNode, nodes.endNode, 0);
Assert.IsTrue(result.terminal);
Assert.AreEqual(4, result.sum);
}
public void Four_By_Four_Grid()
{
var grid = new Grid(4, 4, new long[] {
4, 8, 100, -1000,
70, -10, 2000, 70,
-5, -21, -6, 8,
10000, -20, 15, 21
});
var adapter = new GridGraphProxiedAdapter(grid);
var nodes = adapter.GetGraph(0, 0, 3, 3);
var result = TreeTraverser.BrutForceMaxPathDFS(nodes.startNode, nodes.endNode, 0);
Assert.IsTrue(result.terminal);
Assert.AreEqual(result.sum, 12270);
}
public void Two_By_Two_Grid()
{
var grid = new Grid(2, 2, new long[] {
4, -8,
70, 10
});
var adapter = new GridGraphProxiedAdapter(grid);
var nodes = adapter.GetGraph(0, 0, 1, 1);
var result = TreeTraverser.BrutForceMaxPathDFS(nodes.startNode, nodes.endNode, 0);
var adapter2 = new GridGraphProxiedAdapter(grid);
var nodes2 = adapter2.GetGraph(0, 0, 1, 1);
var result2 = TreeTraverser.OrderedMaxPath(nodes2.startNode, nodes2.endNode, adapter2.nodes);
Assert.IsTrue(result.terminal);
Assert.AreEqual(result2, result.sum);
}
public void Three_By_Three_Grid()
{
var grid = new Grid(3, 3, new long[] {
4, 8, 100,
70, -10, 2000,
-5, -21, -6
});
var adapter = new GridGraphProxiedAdapter(grid);
var nodes = adapter.GetGraph(0, 0, 2, 2);
var result = TreeTraverser.BrutForceMaxPathDFS(nodes.startNode, nodes.endNode, 0);
var adapter2 = new GridGraphProxiedAdapter(grid);
var nodes2 = adapter2.GetGraph(0, 0, 2, 2);
var result2 = TreeTraverser.OrderedMaxPath(nodes2.startNode, nodes2.endNode, adapter2.nodes);
Assert.IsTrue(result.terminal);
Assert.AreEqual(result.sum, result2);
}
public void Eight_By_Eight_Grid()
{
var grid = new Grid(8, 8, new long[] {
4, 8, 100, -1000, 4, 8, 100, -1000,
70, -10, 2000, 70, 70, -10, 2000, 70,
-5, -21, -6, 8, -5, -21, -6, 8,
10000, -20, 15, 21, 10000, -20, 15, 21,
4, 8, 100, -1000, 4, 8, 100, -1000,
70, -10, 2000, 70, 70, -10, 2000, 70,
-5, -21, -6, 8, -5, -21, -6, 8,
10000, -20, 15, 21, 10000, -20, 15, 21
});
var adapter = new GridGraphProxiedAdapter(grid);
var nodes = adapter.GetGraph(0, 0, 7, 7);
var result = TreeTraverser.OrderedMaxPath(nodes.startNode, nodes.endNode, adapter.nodes);
Assert.AreEqual(47799, result);
}
public void Setup()
{
/*
* root
* / | \
* a b c
* /|\ |
* / | \ |
* aa ab ac ca
* /|\ |\
* / | \ | \
* aba abb abc caa cab
* */
root = new TestTreePart("root");
var a = new TestTreePart(root, "a");
b = new TestTreePart(root, "b");
var c = new TestTreePart(root, "c");
var a_a = new DerivedTreePart(a, "a.a");
var a_b = new TestTreePart(a, "a.b");
a_c = new DerivedTreePart(a, "a.c");
a_b_a = new DerivedTreePart(a_b, "a.b.a");
a_b_b = new TestTreePart(a_b, "a.b.b");
a_b_c = new TestTreePart(a_b, "a.b.c");
var c_a = new TestTreePart(c, "c.a");
c_a_a = new TestTreePart(c_a, "c.a.a");
end = new TestTreePart(c_a, "c.a.b");
m_tree = new TreeTraverser <TestTreePart>(root);
Logger.Enable();
Logger.SetFlushAfterEachLog(true);
}
public void WhenTraversingLoopingTree_WithCycleHandlingTruncate_FindsCorrectPaths()
{
NTreeNode tree = GenerateTreeWithCycle();
IEnumerable <IEnumerable <string> > paths = TreeTraverser
.GetTraversalPaths(tree, node => node.Children, CyclicGraphBehaviour.Truncate)
.Select(path => path.Select(node => node.Label).ToArray())
.ToArray();
string[][] expected = new[]
{
new[] { "A", "B", "D", "H" },
new[] { "A", "B", "D", "I" },
new[] { "A", "B", "E", "J" },
new[] { "A", "C", "F", "L" },
new[] { "A", "C", "F", "M" },
new[] { "A", "C", "G", "N" },
new[] { "A", "C", "G", "O" },
new[] { "A", "B", "E", "K", "B" }
};
Assert.Equal(expected, paths);
}
public void WhenTraversingSimpleTree_FindsCorrectPaths()
{
NTreeNode tree = GenerateTree();
IEnumerable <IEnumerable <string> > paths = TreeTraverser
.GetTraversalPaths(tree, node => node.Children)
.Select(path => path.Select(node => node.Label).ToArray())
.ToArray();
string[][] expected = new[]
{
new[] { "A", "B", "D", "H" },
new[] { "A", "B", "D", "I" },
new[] { "A", "B", "E", "J" },
new[] { "A", "B", "E", "K" },
new[] { "A", "C", "F", "L" },
new[] { "A", "C", "F", "M" },
new[] { "A", "C", "G", "N" },
new[] { "A", "C", "G", "O" },
};
Assert.Equal(expected, paths);
}
public void Task04_LeavesFirstTraversal()
{
Node tree1Root = BuildTree(input1);
Assert.AreEqual("2 4 8 3 6 4 9 5", TreeTraverser.Traverse4_LeavesFirst(tree1Root));
}
public void Task03_RootFirstTraversal()
{
Node tree1Root = BuildTree(input1);
Assert.AreEqual("5 4 9 3 6 2 4 8", TreeTraverser.Traverse3_RootFirst(tree1Root));
}
public void Task02_DescendingOrderTraversal()
{
Node tree1Root = BuildTree(input1);
Assert.AreEqual("9 8 6 5 4 4 3 2", TreeTraverser.Traverse2_DescendingOrder(tree1Root));
}
public void Task01_AscendingOrderTraversal()
{
Node tree1Root = BuildTree(input1);
Assert.AreEqual("2 3 4 4 5 6 8 9", TreeTraverser.Traverse1_AscendingOrder(tree1Root));
}
public void WhenTraversingLoopingTree_WithCycleHandlingThrow_ThrowsCyclicGraphException()
{
NTreeNode tree = GenerateTreeWithCycle();
Assert.Throws <CyclicGraphException>(() => TreeTraverser.GetTraversalPaths(tree, node => node.Children, CyclicGraphBehaviour.Throw).ToList());
}