public void OnVisitSyntaxNode(T syntaxNode) { VisitedNodes.Add(syntaxNode); if (_callback is object) { _callback(syntaxNode); } }
public void Init(int startNodeId) { StartNodeId = startNodeId; Distance = 0; VisitedNodes.Add(Graph.Points.Where(x => x.Id == startNodeId).First()); UnvisitedNodes = Graph.Points.Where(x => x.Id != startNodeId).ToList(); Path.Clear(); }
public void visitNode(uint u) { if (CurrentNode != null) { VisitedNodes.Add(CurrentNode); } CurrentNode = Convert.ToInt32(u); NotifyStateChanged(); }
private void ProcessPath(string path) { var inputs = path.ToCharArray(); foreach (var next in inputs.Select(input => new Direction(input)).Select(dir => Point + dir.Translation).Where(next => Graph.Map.ContainsKey(next))) { Node = Graph.GetNodeFrom(next); Point = next; VisitedNodes.Add(Node); } }
public bool A_StarAlgorithm(Node Start, Node Target) { Node CurrentNode = Start; ActualNodes.Add(CurrentNode); for (; ActualNodes.Count > 0;) { CurrentNode = ActualNodes[0]; if (CurrentNode.Equals(Target)) { VisitedNodes.Add(Target); for (int Index = 0; Index < VisitedNodes.Count - 1; Index++) { ShortesPath.Add(InnerGraph.FindEdge(VisitedNodes[Index], VisitedNodes[Index + 1])); } return(true); } ActualNodes.Remove(CurrentNode); ClosedNodes.Add(CurrentNode); foreach (Node Incomer in CurrentNode.Incomers.Where(Node => Node != null && Node.Index != Node.Incomers.Length - 1)) { if (!ClosedNodes.Contains(Incomer)) { if (!ActualNodes.Contains(Incomer)) { Incomer[Incomer.Index] = CurrentNode; Incomer.HeuristicCost = HeruisticPath(Incomer, Target); Incomer.PastWayCost = InnerGraph.FindEdge(CurrentNode, Incomer).Weight; Incomer.TotalPathCost = Incomer.PastWayCost + Incomer.HeuristicCost; ActualNodes.Add(Incomer); ActualNodes = ActualNodes.OrderBy(Node => Node.TotalPathCost).ToList <Node>(); } } } VisitedNodes.Add(CurrentNode); } return(true); }
public bool FindTheShortesPath(Node Start, Node Target) { Node CurrentNode = Start; OpenList.Add(CurrentNode); for (; OpenList.Count > 0;) { CurrentNode = OpenList[0]; if (CurrentNode.Equals(Target)) { VisitedNodes.Add(Target); for (int Index = 0; Index < VisitedNodes.Count - 1; Index++) { ShortesPath.Add(InnerGraph.FindEdge(VisitedNodes[Index], VisitedNodes[Index + 1])); } return(true); } OpenList.Remove(CurrentNode); ClosedList.Add(CurrentNode); foreach (Node Inheritor in CurrentNode.Inheritors.Where(Node => Node != null && Node.Index != Node.Inheritors.Length - 1)) { if (!ClosedList.Contains(Inheritor)) { if (!OpenList.Contains(Inheritor)) { Inheritor[Inheritor.Index] = CurrentNode; Inheritor.HeuristicPathWeight = CalculateHeuristic(Inheritor, Target); Inheritor.GainedPathWeight = InnerGraph.FindEdge(CurrentNode, Inheritor).Weight; Inheritor.TotalPathWeight = Inheritor.GainedPathWeight + Inheritor.HeuristicPathWeight; OpenList.Add(Inheritor); OpenList = OpenList.OrderBy(Node => Node.TotalPathWeight).ToList <Node>(); } } } VisitedNodes.Add(CurrentNode); } return(true); }
public void Init(int startNodeId) { StartNodeId = startNodeId; Distance = 0; List <Point> visitedPoints = Graph.Points.Where(x => x.Id == startNodeId).ToList(); if (visitedPoints.Count > 0) { VisitedNodes.Add(visitedPoints.First()); } UnvisitedNodes = Graph.Points.Where(x => x.Id != startNodeId).ToList(); Path.Clear(); }
private bool DoSearch() { AssignCurrentVertex(); if (VisitedNodes.Contains(Current)) { return(MoveNext()); } VisitedNodes.Add(Current); PushNeighborsToStack(); return(true); }
public bool DepthFirstSearch(Node Start) { VisitedNodes.Add(Start); for (int Index = 0; Index < InnerGraph.NumberOfNodes; Index++) { if (InnerGraph.SetOfNodes[Start.Index][Index] != null && !VisitedNodes.Contains(InnerGraph.SetOfNodes[Index])) { ResultOfSearching.Add(InnerGraph.FindEdge(Start, InnerGraph.SetOfNodes[Index])); DepthFirstSearch(InnerGraph.SetOfNodes[Index]); } } return(VisitedNodes.Count.Equals(InnerGraph.NumberOfNodes)); }
/// bool BreadthFirstSearch(Node Start) starting from StartNode /// adding that Node in queue, afterthat starting cycle for all Graph /// </summary> /// <param name="Start"></param> - first Node /// <returns></returns> public bool BreadthFirstSearch(Node Start) { Queue.Enqueue(Start); VisitedNodes.Add(Start); for (; Queue.Count > 0;) { Start = Queue.Dequeue(); for (int Index = 0; Index < InnerGraph.QuantityOfNodes; Index++) { if (InnerGraph.SetOfNodes[Start.Index][Index] != null && !VisitedNodes.Contains(InnerGraph.SetOfNodes[Index])) { ResultOfSearching.Add(InnerGraph.FindEdge(Start, InnerGraph.SetOfNodes[Index])); Queue.Enqueue(InnerGraph.SetOfNodes[Index]); VisitedNodes.Add(InnerGraph.SetOfNodes[Index]); } } } return(VisitedNodes.Count.Equals(InnerGraph.QuantityOfNodes)); }
public Edge Move() { Point endPoint; var startPoint = CurrentNode(); if (UnvisitedNodes.Count == 0) { endPoint = VisitedNodes[0]; // if ant visited every node, just go back to start } else { endPoint = ChooseNextPoint(); VisitedNodes.Add(endPoint); UnvisitedNodes.RemoveAt(UnvisitedNodes.FindIndex(x => x.Id == endPoint.Id)); } var edge = Graph.GetEdge(startPoint.Id, endPoint.Id); Path.Add(edge); Distance += edge.Length; return(edge); }
public bool FindMinimumSpanningTree() { VisitedNodes.Add(InnerGraph.SetOfNodes[0]); for (; VisitedNodes.Count < InnerGraph.NumberOfNodes;) { Node Start = new Node(); Node End = new Node(); Edge CurrentEdge = new Edge { Weight = Infinity }; for (int Index = 0; Index < InnerGraph.NumberOfNodes; Index++) { if (VisitedNodes.Contains(InnerGraph.SetOfNodes[Index])) { foreach (Node Inheritor in InnerGraph.SetOfNodes[Index].Inheritors.Where(Node => Node != null && !VisitedNodes.Contains(Node))) { if (CurrentEdge.Weight > InnerGraph.FindEdge(InnerGraph.SetOfNodes[Index], Inheritor).Weight) { CurrentEdge = InnerGraph.FindEdge(InnerGraph.SetOfNodes[Index], Inheritor); Start = CurrentEdge[0]; End = CurrentEdge[1]; } } } } VisitedNodes.Add(End); MinimumSpanningTree.Add(InnerGraph.FindEdge(Start, End)); } return(VisitedNodes.Count.Equals(InnerGraph.NumberOfNodes)); }
public bool DepthFirstSearch(Node Start, Node Target) { VisitedNodes.Add(Start); if (VisitedNodes.Contains(Target)) { return(true); } for (int Index = 0; Index < InnerGraph.NumberOfNodes; Index++) { if (InnerGraph.SetOfNodes[Start.Index][Index] != null && !VisitedNodes.Contains(InnerGraph.SetOfNodes[Index])) { ResultOfSearching.Add(InnerGraph.FindEdge(Start, InnerGraph.SetOfNodes[Index])); if (DepthFirstSearch(InnerGraph.SetOfNodes[Index], Target)) { return(true); } } } return(VisitedNodes.Contains(Target)); }
public bool DepthFirstSearch(Node Start, Node Target, Node[] FoundPath) { VisitedNodes.Add(Start); if (VisitedNodes.Contains(Target)) { return(true); } for (int Index = 0; Index < InnerGraph.NumberOfNodes; Index++) { if (InnerGraph.SetOfNodes[Start.Index][Index] != null && !VisitedNodes.Contains(InnerGraph.SetOfNodes[Index]) && InnerGraph.FindEdge(Start, InnerGraph.SetOfNodes[Index]).Weight > 0) { FoundPath[Index] = Start; if (DepthFirstSearch(InnerGraph.SetOfNodes[Index], Target, FoundPath)) { return(true); } } } return(VisitedNodes.Contains(Target)); }
public void OnVisitSyntaxNode(SyntaxNode syntaxNode) { VisitedNodes.Add(syntaxNode); }