public List <ShortestResponse> GetAllPaths(SearchReq request) { MethodBase currentMethod = MethodBase.GetCurrentMethod(); try { DepthFirstTraversal graph = new DepthFirstTraversal(9); graph.addEdge(0, 1); graph.addEdge(0, 2); graph.addEdge(1, 2); graph.addEdge(1, 4); graph.addEdge(2, 1); graph.addEdge(2, 6); graph.addEdge(3, 8); graph.addEdge(4, 0); graph.addEdge(4, 2); graph.addEdge(5, 0); graph.addEdge(5, 6); graph.addEdge(6, 5); graph.addEdge(6, 7); graph.addEdge(7, 8); graph.addEdge(8, 2); graph.addEdge(8, 3); var source = graph.datacode.FirstOrDefault(x => x.Key == request.source).Value; var destination = graph.datacode.FirstOrDefault(x => x.Key == request.destination).Value; graph.printAllPaths(source, destination); return(graph.ShortestResponses); } catch (Exception ex) { AirlineLogManager.Error(null, CurrentClass, currentMethod, ex); } return(null); }
public void PostOrderTest() { var graph = new Graph(); graph.Nodes.Add("0"); graph.Nodes.Add("1"); graph.Nodes.Add("2"); graph.Nodes.Add("3"); graph.Nodes.Add("4"); graph.Edges.Add("0", "2"); graph.Edges.Add("2", "1"); graph.Edges.Add("1", "0"); graph.Edges.Add("0", "3"); graph.Edges.Add("3", "4"); var traversal = new DepthFirstTraversal(); var recorder = new PostOrderRecorder(traversal); traversal.Run(graph.Nodes["0"]); var order = recorder.GetOrder(); Assert.Equal(order.Count, graph.Nodes.Count); Assert.All(graph.Nodes, n => Assert.True(order.IndexOf(graph.Nodes["0"]) >= order.IndexOf(n))); Assert.True(order.IndexOf(graph.Nodes["1"]) < order.IndexOf(graph.Nodes["2"])); Assert.True(order.IndexOf(graph.Nodes["4"]) < order.IndexOf(graph.Nodes["3"])); }
/// <summary> /// Replace one node with another. /// </summary> /// <param name="rootNode">The root node.</param> /// <param name="replaceThisNode">The node to replace.</param> /// <param name="replaceWith">What to replace with.</param> public static void Process(ITreeNode rootNode, ITreeNode replaceThisNode, ITreeNode replaceWith) { bool done = false; DepthFirstTraversal trav = new DepthFirstTraversal(); trav.Traverse(rootNode, (n) => { if (done) { return false; } for (int i = 0; i < n.ChildNodes.Count; i++) { ITreeNode childNode = n.ChildNodes[i]; if (childNode == replaceThisNode) { n.ChildNodes[i] = replaceWith; done = true; return false; } } return true; }); }
/// <summary> /// Replace one node with another. /// </summary> /// <param name="rootNode">The root node.</param> /// <param name="replaceThisNode">The node to replace.</param> /// <param name="replaceWith">What to replace with.</param> public static void Process(ITreeNode rootNode, ITreeNode replaceThisNode, ITreeNode replaceWith) { bool done = false; DepthFirstTraversal trav = new DepthFirstTraversal(); trav.Traverse(rootNode, (n) => { if (done) { return(false); } for (int i = 0; i < n.ChildNodes.Count; i++) { ITreeNode childNode = n.ChildNodes[i]; if (childNode == replaceThisNode) { n.ChildNodes[i] = replaceWith; done = true; return(false); } } return(true); }); }
public void TestDFSUnDirectedGraph() { IGraph graph = new Graph(); graph.AddNode(new Node("s")); graph.AddNode(new Node("a")); graph.AddNode(new Node("b")); graph.AddNode(new Node("c")); graph.AddNode(new Node("d")); graph.AddNode(new Node("e")); graph.BuildEdge("s", "a", 0); graph.BuildEdge("s", "b", 0); graph.BuildEdge("a", "c", 0); graph.BuildEdge("a", "b", 0); graph.BuildEdge("b", "d", 0); graph.BuildEdge("c", "e", 0); graph.BuildEdge("c", "d", 0); graph.BuildEdge("d", "e", 0); DepthFirstTraversal dfs = new DepthFirstTraversal(graph, graph.GetNodeByID("s")); TraversalResult tr = dfs.Run(); Assert.Equal("s,a,c,e,d,b", string.Join(",", tr.Nodes.Select(node => node.ID))); }
/// <summary> /// Checks whether there is a definition from the beginning to the use node /// </summary> /// <param name="fdef"></param> /// <param name="otherDefinedOffsets"></param> /// <returns></returns> private bool HasDefinitionFromRootToUseNode(DUCoverStore dcs, FieldDefUseStore fuse, HashSet <int> otherDefinedOffsets) { DEFUSE_FEASIBILITY_TYPE feasibilityVal; if (this.feasibilityDicCache.TryGetValue(fuse, out feasibilityVal)) { if (feasibilityVal == DEFUSE_FEASIBILITY_TYPE.USE_FEASIBLE) { return(false); } else { return(true); } } InstructionGraph ig = dcs.GetInstructionGraph(fuse.Method); DepthFirstTraversal dft = new DepthFirstTraversal(ig); InstructionVertex iv = ig.GetVertex(fuse.Offset); var result = dft.HasDefClearPathFromBeginning(iv, otherDefinedOffsets); if (result) { this.feasibilityDicCache[fuse] = DEFUSE_FEASIBILITY_TYPE.USE_FEASIBLE; } else { this.feasibilityDicCache[fuse] = DEFUSE_FEASIBILITY_TYPE.USE_INFEASIBLE; } return(!result); }
public void TestDFSDirectedGraph() { INode node1 = new Node("1"); INode node2 = new Node("2"); INode node3 = new Node("3"); INode node4 = new Node("4"); INode node5 = new Node("5"); IGraph graph = new Graph(true); graph.AddNode(node1); graph.AddNode(node2); graph.AddNode(node3); graph.AddNode(node4); graph.AddNode(node5); graph.BuildEdge(node1, node2, 0); graph.BuildEdge(node1, node3, 0); graph.BuildEdge(node2, node4, 0); graph.BuildEdge(node2, node5, 0); DepthFirstTraversal dfs = new DepthFirstTraversal(graph, node1); TraversalResult traversalResult = dfs.Run(); string result = string.Join(",", traversalResult.Nodes.Select(node => node.ID)); Assert.Equal("1,2,4,5,3", result); }
public void If() { // Artificially construct an if construct. var graph = TestGraphs.CreateIfElse(); var n1 = graph.GetNodeById(1); var n2 = graph.GetNodeById(2); var n3 = graph.GetNodeById(3); var n4 = graph.GetNodeById(4); // Record a depth first traversal. var traversal = new DepthFirstTraversal(); var recorder = new TraversalOrderRecorder(traversal); traversal.Run(n1); // Check if n1 is before any node in the traversal. Assert.All(graph.GetNodes(), n => Assert.True(n1 == n || recorder.GetIndex(n1) < recorder.GetIndex(n))); // DFS should either pick n2 or n3. If n2, then n4 is before n3, otherwise before n2. if (recorder.GetIndex(n2) < recorder.GetIndex(n3)) { Assert.True(recorder.GetIndex(n4) < recorder.GetIndex(n3)); } else { Assert.True(recorder.GetIndex(n4) < recorder.GetIndex(n2)); } }
public void DepthFirstDepthShouldBeTwoWhenEndNodeIsFoundTest() { // Arrange var start = Tree.Nodes["1"]; var stop = Tree.Nodes["5"]; var traversal = new DepthFirstTraversal(); Node result = null; int depth = 0; traversal.NodeDiscovered += (sender, args) => { if (args.NewNode == stop) { args.ContinueExploring = false; args.Abort = true; result = args.NewNode; depth = args.Depth; } }; // Act traversal.Run(start); // Assert Assert.Equal(stop, result); Assert.Equal(2, depth); }
/// <summary> /// Count the nodes from this tree node. /// </summary> /// <param name="node">The tree node.</param> /// <returns>The node count.</returns> public static int Process(ITreeNode node) { int result = 0; DepthFirstTraversal trav = new DepthFirstTraversal(); trav.Traverse( node, (n) => { result++; return true; }); return result; }
public void SingleNode() { var graph = TestGraphs.CreateSingularGraph(); var startNode = graph.GetNodeById(1); // Record a depth first traversal. var traversal = new DepthFirstTraversal(); var recorder = new TraversalOrderRecorder(traversal); traversal.Run(startNode); Assert.Single(recorder.GetTraversal()); Assert.Equal(0, recorder.GetIndex(startNode)); }
/// <summary> /// Count the nodes from this tree node. /// </summary> /// <param name="node">The tree node.</param> /// <returns>The node count.</returns> public static int Process(ITreeNode node) { int result = 0; DepthFirstTraversal trav = new DepthFirstTraversal(); trav.Traverse(node, (n) => { result++; return(true); }); return(result); }
public void CollectionOfAllNodes() { var vertices = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; var edges = new[] { Tuple.Create(1, 2), Tuple.Create(1, 3), Tuple.Create(2, 4), Tuple.Create(3, 5), Tuple.Create(3, 6), Tuple.Create(4, 7), Tuple.Create(5, 7), Tuple.Create(5, 8), Tuple.Create(5, 6), Tuple.Create(8, 9), Tuple.Create(9, 10) }; Graph <int> graph = new Graph <int>(vertices, edges); var algorithms = new DepthFirstTraversal(); var dft = algorithms.DFS(graph, 1); Assert.Equal(dft.Count, graph.AdjacencyList.Count); }
public void DepthFirstOrderTest() { var traversal = new DepthFirstTraversal(); var recorder = new TraversalOrderRecorder(traversal); traversal.Run(Tree.Nodes["1"]); if (recorder.GetIndex(Tree.Nodes["2"]) < recorder.GetIndex(Tree.Nodes["3A"])) { Assert.True(recorder.GetIndex(Tree.Nodes["4A"]) < recorder.GetIndex(Tree.Nodes["3A"])); } else { Assert.True(recorder.GetIndex(Tree.Nodes["5"]) < recorder.GetIndex(Tree.Nodes["4A"])); } }
private static void Main() { IGraph <char> graph = new Graph <char>(); var a = graph.AddVertex('A'); var b = graph.AddVertex('B'); var c = graph.AddVertex('C'); var d = graph.AddVertex('D'); var e = graph.AddVertex('E'); graph.AddEdge(a, b, 6); graph.AddEdge(b, a, 6); graph.AddEdge(a, d, 1); graph.AddEdge(d, a, 1); graph.AddEdge(d, e, 1); graph.AddEdge(e, d, 1); graph.AddEdge(d, b, 2); graph.AddEdge(b, d, 2); graph.AddEdge(e, b, 2); graph.AddEdge(b, e, 2); graph.AddEdge(e, c, 5); graph.AddEdge(c, e, 5); graph.AddEdge(c, b, 5); graph.AddEdge(b, c, 5); Console.WriteLine("Depth-First recursive traversal: "); DepthFirstTraversal <char> .DepthFirstSearchIterative(graph, a); graph.Reset(); Console.WriteLine("Depth-First iterative path between two vertices: "); var depthFirstIterative = DepthFirstTraversal <char> .DepthFirstIterative(graph, a, e); foreach (var vertex in depthFirstIterative) { Console.WriteLine(vertex); } }
public void DepthFirstDepthShouldBeZeroOnFirstNodeTest() { // Arrange var start = new Node("7"); Tree.Nodes.Add(start); var traversal = new DepthFirstTraversal(); traversal.NodeDiscovered += (sender, args) => { Assert.Equal(0, args.Depth); }; // Act traversal.Run(start); // Assert done in NodeDiscoverd event handler. }
public void PathReversed() { // Artificially construct a path of four nodes in sequential order. var graph = TestGraphs.CreatePath(); // Record a depth first traversal. var traversal = new DepthFirstTraversal(true); var recorder = new TraversalOrderRecorder(traversal); traversal.Run(graph.GetNodeById(4)); // Traversal should exactly be the path. Assert.Equal(new INode[] { graph.GetNodeById(4), graph.GetNodeById(3), graph.GetNodeById(2), graph.GetNodeById(1), }, recorder.GetTraversal()); }
/// <summary> /// Checks whether a definition and use are in different methods /// </summary> /// <param name="dcse"></param> /// <returns></returns> private bool IsFeasibleDUCoverEntry(DUCoverStore dcs, FieldDefUseStore fdef, FieldDefUseStore fuse) { //if (fdef.Method.FullName.Contains("AddVertex") && fuse.Method.FullName.Contains("AddVertex") && fdef.Field.FullName.Contains("m_VertexOutEdges") // && fdef.Offset == 13 && fuse.Offset == 2) //{ // int i = 0; //} //check whether the def and use are in the same method if (fdef.Method.Equals(fuse.Method)) { var otherFDefOffsets = this.GetOtherDefOffsetsInMethod(fdef.Method, fdef); InstructionGraph ig = dcs.GetInstructionGraph(fdef.Method); DepthFirstTraversal dft = new DepthFirstTraversal(ig); var source = ig.GetVertex(fdef.Offset); var target = ig.GetVertex(fuse.Offset); return(dft.HasDefClearPathBetweenNodes(source, target, otherFDefOffsets)); } else { var otherFDefOffsets = this.GetOtherDefOffsetsInMethod(fdef.Method, fdef); if (otherFDefOffsets.Count > 0) { if (this.HasRedefinition(dcs, fdef, otherFDefOffsets)) { return(false); } } otherFDefOffsets = this.GetOtherDefOffsetsInMethod(fuse.Method, fdef); if (otherFDefOffsets.Count > 0) { if (this.HasDefinitionFromRootToUseNode(dcs, fuse, otherFDefOffsets)) { return(false); } } return(true); } }
public void LoopReversed() { // Artificially construct a looping construct. var graph = TestGraphs.CreateLoop(); var n1 = graph.GetNodeById(1); var n2 = graph.GetNodeById(2); var n3 = graph.GetNodeById(3); var n4 = graph.GetNodeById(4); // Record a depth first traversal. var traversal = new DepthFirstTraversal(true); var recorder = new TraversalOrderRecorder(traversal); traversal.Run(n4); // Check if n1 is before any node in the traversal. Assert.All(graph.GetNodes(), n => Assert.True(n4 == n || recorder.GetIndex(n4) < recorder.GetIndex(n))); Assert.True(recorder.GetIndex(n1) > recorder.GetIndex(n3)); }
/// <summary> /// Obtain the specified tree node for the specified index. /// </summary> /// <param name="index">The index.</param> /// <param name="node">The tree node to search from.</param> /// <returns>The tree node for the specified index.</returns> public static ITreeNode process(int index, ITreeNode node) { ITreeNode result = null; int nodeCount = 0; DepthFirstTraversal trav = new DepthFirstTraversal(); trav.Traverse(node, (n) => { if ( nodeCount >= index) { if (result == null) { result = n; } return false; } nodeCount++; return true; }); return result; }
/// <summary> /// Determines whether a graph contains at least one cycle. /// </summary> /// <param name="graph">The graph to test.</param> /// <returns>True if the graph is cyclic, false otherwise.</returns> public static bool IsCyclic(this Graph graph) { var visited = new HashSet <Node>(); foreach (var node in graph.Nodes) { if (!visited.Add(node)) { return(false); } bool cycleDetected = false; var reachableNodes = new HashSet <Node>(); var visitedEdges = new HashSet <Edge>(); var traversal = new DepthFirstTraversal(); traversal.NodeDiscovered += (sender, args) => { if (visitedEdges.Add(args.Origin) && !reachableNodes.Add(args.NewNode)) { args.ContinueExploring = false; cycleDetected = true; } }; traversal.Run(node); if (cycleDetected) { return(true); } visited.UnionWith(reachableNodes); } return(false); }
/// <summary> /// Obtain the specified tree node for the specified index. /// </summary> /// <param name="index">The index.</param> /// <param name="node">The tree node to search from.</param> /// <returns>The tree node for the specified index.</returns> public static ITreeNode process(int index, ITreeNode node) { ITreeNode result = null; int nodeCount = 0; DepthFirstTraversal trav = new DepthFirstTraversal(); trav.Traverse(node, (n) => { if (nodeCount >= index) { if (result == null) { result = n; } return(false); } nodeCount++; return(true); }); return(result); }
public static ICollection <ISet <Node> > FindStronglyConnectedComponents(this Node entrypoint) { var graph = entrypoint.ParentGraph; var traversal = new DepthFirstTraversal(); var recorder = new PostOrderRecorder(traversal); traversal.Run(entrypoint); var transpose = graph.Transpose(); var visited = new HashSet <Node>(); var result = new List <ISet <Node> >(); foreach (var node in recorder.GetOrder().Reverse()) { if (!visited.Contains(node)) { var subTraversal = new DepthFirstTraversal(); var component = new HashSet <Node>(); subTraversal.NodeDiscovered += (sender, args) => { if (visited.Add(graph.Nodes[args.NewNode.Name])) { args.ContinueExploring = true; component.Add(graph.Nodes[args.NewNode.Name]); } }; subTraversal.Run(transpose.Nodes[node.Name]); result.Add(component); } } return(result); }
/// <summary> /// Computes the dominator tree of a control flow graph, defined by its entrypoint. /// </summary> /// <param name="entrypoint">The entrypoint of the control flow graph.</param> /// <returns>A dictionary mapping all the nodes to their immediate dominator.</returns> /// <remarks> /// The algorithm used is based on the one engineered by Lengauer and Tarjan. /// https://www.cs.princeton.edu/courses/archive/fall03/cs528/handouts/a%20fast%20algorithm%20for%20finding.pdf /// https://www.cl.cam.ac.uk/~mr10/lengtarj.pdf /// </remarks> private static IDictionary <IIdentifiedNode, IIdentifiedNode> GetImmediateDominators(IIdentifiedNode entrypoint) { var idom = new Dictionary <IIdentifiedNode, IIdentifiedNode>(); var semi = new Dictionary <IIdentifiedNode, IIdentifiedNode>(); var ancestor = new Dictionary <IIdentifiedNode, IIdentifiedNode>(); var bucket = new Dictionary <IIdentifiedNode, ISet <IIdentifiedNode> >(); var traversal = new DepthFirstTraversal(); var order = new TraversalOrderRecorder(traversal); var parents = new ParentRecorder(traversal); traversal.Run(entrypoint); var orderedNodes = order.GetTraversal(); foreach (var node in orderedNodes.Cast <IIdentifiedNode>()) { idom[node] = null; semi[node] = node; ancestor[node] = null; bucket[node] = new HashSet <IIdentifiedNode>(); } for (int i = orderedNodes.Count - 1; i >= 1; i--) { var current = (IIdentifiedNode)orderedNodes[i]; var parent = (IIdentifiedNode)parents.GetParent(current); // step 2 foreach (var predecessor in current.GetPredecessors().Cast <IIdentifiedNode>()) { var u = Eval(predecessor, ancestor, semi, order); if (order.GetIndex(semi[current]) > order.GetIndex(semi[u])) { semi[current] = semi[u]; } } bucket[semi[current]].Add(current); Link(parent, current, ancestor); // step 3 foreach (var bucketNode in bucket[parent]) { var u = Eval(bucketNode, ancestor, semi, order); if (order.GetIndex(semi[u]) < order.GetIndex(semi[bucketNode])) { idom[bucketNode] = u; } else { idom[bucketNode] = parent; } } bucket[parent].Clear(); } // step 4 for (int i = 1; i < orderedNodes.Count; i++) { var w = (IIdentifiedNode)orderedNodes[i]; if (idom[w] != semi[w]) { idom[w] = idom[idom[w]]; } } idom[entrypoint] = entrypoint; return(idom); }
public DepthFirstTraversalTest() { depthFirstTraversal = new DepthFirstTraversal <string>(); }