override protected void EvaluateOutputs() { if (ShouldOutput()) { outputPorts[0].Value = queue.Dequeue().value; EmitEvaluationRequired(); } else { outputPorts[0].Value = null; } IConvertible value = InValue(0); if (object.ReferenceEquals(value, lastInput) || (!object.ReferenceEquals(value, null) && value.Equals(lastInput))) { return; } lastInput = value; if (!ValueToBool(value)) { return; } int delay = Math.Max(1, InInt(1)); int outputTick = Manager.CurrentTick + delay; QueueEntry entry = new QueueEntry(outputTick, value); if (queue.Count >= queue.MaxSize) { queue.Dequeue(); } queue.Enqueue(entry, outputTick); }
static void TestCase4() { var random = new Random(); var myHeap = new FibonacciHeap<double>(int.MinValue, Comparer<double>.Default); var thirdPartyHeap = new FastPriorityQueue<FastPriorityQueueNode>(1000); for (var i = 0; i < 1000; i++) { if (random.Next(3) == 0 && thirdPartyHeap.Any()) { var myResult = myHeap.ExtractMin(); var otherResult = thirdPartyHeap.Dequeue(); Assert(myResult.Item1); Assert(Math.Abs(myResult.Item2 - otherResult.Priority) < double.Epsilon); } else { var value = random.NextDouble()*10; myHeap.Insert(value); thirdPartyHeap.Enqueue(new FastPriorityQueueNode(), value); } } while (thirdPartyHeap.Any()) { var myResult = myHeap.ExtractMin(); var otherResult = thirdPartyHeap.Dequeue(); Assert(myResult.Item1); Assert(Math.Abs(myResult.Item2 - otherResult.Priority) < double.Epsilon); } }
/// <summary> /// Processes the queue and fires events. /// </summary> private void QueueProcessing() { TimeSpan waitForNewTimeOut = TimeSpan.Zero; while (!_cancellationToken.IsCancellationRequested) { lock (_eventsAvailableLock) { // wait until we're flagged that there are events available. Monitor.Wait(_eventsAvailableLock, waitForNewTimeOut > TimeSpan.Zero ? waitForNewTimeOut : Scheduler._defaultProcessWaitTime); // reset time to wait. waitForNewTimeOut = TimeSpan.Zero; lock (_queueLock) { if (_priorityQueue.First == null) { // no more items on the queue, go to wait. Console.WriteLine($"{nameof(Scheduler)}: Queue empty."); continue; } // store a single 'current' time for processing of all items in the queue // TODO: use 'current' time from Game.Instance var currentTimeInMilliseconds = GetMillisecondsAfterReferenceTime(DateTime.Now); // check the current queue and fire any events that are due. while (_priorityQueue.Count > 0) { // the first item always points to the next-in-time event available. var nextEvent = _priorityQueue.First; // check if this event has been cancelled. if (_cancelledEvents.Contains(nextEvent.EventId)) { // dequeue, clean and move next. _priorityQueue.Dequeue(); CleanAllAttributedTo(nextEvent.EventId, nextEvent.RequestorId); continue; } // check if the event is due if (nextEvent.Priority <= currentTimeInMilliseconds) { // actually dequeue this item. _priorityQueue.Dequeue(); OnEventFired?.Invoke(this, new EventFiredEventArgs(nextEvent)); continue; } // else the next item is in the future, so figure out how long to wait, update and break. waitForNewTimeOut = TimeSpan.FromMilliseconds(nextEvent.Priority < currentTimeInMilliseconds ? 0 : nextEvent.Priority - currentTimeInMilliseconds); break; } } } } }
public byte GetThresholdLevel() { // blend together groups of pixels to average their data and get rid of local spikes int weightedArraySize = DATA_ARRAY_SIZE - 4; uint[] weightedData = new uint[weightedArraySize]; for (int i = 0; i < weightedArraySize; ++i) { weightedData[i] = 4 * Data[i + 2] + 3 * (Data[i + 1] + Data[i + 3]) + Data[i] + Data[i + 4]; } // find highest local maximum (biggest concentration of pixels of a single color int queueSize = (int)Math.Ceiling(weightedArraySize / 2f); FastPriorityQueue<ThresholdPoint> queue = new FastPriorityQueue<ThresholdPoint>(queueSize); for (int i = 1; i < weightedArraySize - 1; ++i) { // check if current point is higher than both of its neighbors if (weightedData[i] > weightedData[i + 1] && weightedData[i] > weightedData[i - 1]) { queue.Enqueue(new ThresholdPoint(i, weightedData[i]), -weightedData[i]); // reversing queue priority to store higher values in front } } // find two highest value groups separated by a certain minimal distance ThresholdPoint a = queue.Dequeue(); ThresholdPoint b = queue.Dequeue(); int minPixelDistance = 16; while (Math.Abs(a.Index - b.Index) < minPixelDistance) { b = queue.Dequeue(); } // switch points around if necessary so that 'a' represents a lower index if (a.Index > b.Index) { ThresholdPoint t = a; a = b; b = t; } // find the lowest value between these two groups uint minVal = a.Value; int minPos = a.Index; for (int i = a.Index + 1; i < b.Index; ++i) { if (weightedData[i] < minVal) { minVal = weightedData[i]; minPos = i; } } return (byte)(minPos + 2); }
/// <summary> /// Benchmark /// </summary> public void EnqueueDequeue() { Enqueue(); for (int i = 0; i < QueueSize; i++) { Queue.Dequeue(); } }
// A* pathfinding on tilemap public static List <Vector3> FindPath(Vector2 start, Vector2 end, Tilemap t, bool useDiagonals) { List <Vector3> ret = new List <Vector3>(); Dictionary <Vector2, Vector2> cameFrom = new Dictionary <Vector2, Vector2>(); Dictionary <Vector2, float> cost = new Dictionary <Vector2, float>(); Vector2 current; float newcost = 0; float dist = 0; FastPriorityQueue <QueueNode> queue = new FastPriorityQueue <QueueNode>(64); queue.Enqueue(new QueueNode(start), 0); cost.Add(start, 0); while (queue.Count != 0) { current = queue.Dequeue().data; if (Vector2.SqrMagnitude(end - current) < 0.5f) { if (!cameFrom.ContainsKey(end) && cameFrom.ContainsKey(current)) { cameFrom.Add(end, cameFrom[current]); } break; } List <Vector3> neighbors; if (useDiagonals) { neighbors = GetTileNeighborDiagonal(t, current); } else { neighbors = GetTileNeighbor(t, current); } foreach (Vector3 neighbor in neighbors) { newcost = cost[current] + 0.5f; if (!cost.ContainsKey(neighbor) || newcost < cost[neighbor]) { cost[neighbor] = newcost; if (useDiagonals) { dist = Mathf.Max(Mathf.Abs(neighbor.x - end.x), Mathf.Abs(neighbor.y - end.y)); } else { dist = Vector2.Distance(neighbor, end); } queue.Enqueue(new QueueNode(neighbor), newcost + dist); cameFrom[neighbor] = current; } } } TraverseCameFrom(end, cameFrom, ret); return(ret); }
private Node <T> BuildGraphAndReturnGoalNode(T startPosition, T goalPosition) { _frontier = new FastPriorityQueue <Node <T> >(150); _graph = new Node <T> [_maxNumberOfNodes]; var heuristic = new Func <T, float>(position => _heuristic(position, goalPosition)); var initial = new Node <T>(startPosition, _indexMap(startPosition)); _frontier.Enqueue(initial, 0); _graph[initial.Index] = initial; while (_frontier.Count > 0) { var current = _frontier.Dequeue(); if (current.Position.Equals((goalPosition))) { return(current); } AddNeighbours(current, heuristic); _debug?.Invoke(_graph); } return(null); }
public override object Part2() { var map = Parse(); var queue = new FastPriorityQueue <QueueNode>(20000); queue.Enqueue(new QueueNode((0, 0), Tool.Torch, 0), 0); var shortestPath = new Dictionary <(int x, int y, Tool tool), int>(); while (true) { var cur = queue.Dequeue(); if (shortestPath.TryGetValue(cur.Key, out var shortest) && shortest <= cur.Len) { continue; } shortestPath[cur.Key] = cur.Len; if (cur.Key == map.Target) { return(cur.Len); } foreach (var t in map.Tools(cur.Coord).Where(x => x != cur.Tool)) { queue.Enqueue(new QueueNode(cur.Coord, t, cur.Len + 7), cur.Len + 7); } foreach (var nc in cur.Neighbours().Where(nc => map.Tools(nc).Contains(cur.Tool))) { queue.Enqueue(new QueueNode(nc, cur.Tool, cur.Len + 1), cur.Len + 1); } } }
public void AStar(Coord2D from, Coord2D to) { Stopwatch stopWatch = new Stopwatch(); stopWatch.Start(); // Initialize start node int initialHeuristic = EuclideanDistance(from, to); TileNode startNode = new TileNode(from.x, from.y, 0, initialHeuristic); // Store start node nodeQueue.Enqueue(startNode, startNode.totalCost); nodeTracker[startNode.y, startNode.x] = startNode; int timeC = 0; while (true) { // timeC++; // if (timeC > 14) // { // yield return null; // timeC = 0; // } if (nodeQueue.Count == 0) // If the queue is empty, exit and fail { print("UNABLE TO FIND PATH!"); break; } TileNode bestNode = nodeQueue.Dequeue(); transform.position = new Vector3(bestNode.x, bestNode.y, 1); GameObject.Instantiate(frontierMarker).transform.position = transform.position; // Set closed state and break if dest. reached if (SetClosedState(bestNode)) { ShowBestPath(bestNode); break; } AScanAdjacent(bestNode); } stopWatch.Stop(); // Get the elapsed time as a TimeSpan value. TimeSpan ts = stopWatch.Elapsed; // Format and display the TimeSpan value. string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10); print("RunTime " + elapsedTime); }
public void DijkstraShortestPath(int source, int exitIndex) { int length = width * height; int[] preCopy = new int[length * 4]; for (int i = 0; i < preCopy.Length; ++i) { preCopy[i] = -1; } initVar(); distance[source] = 0; queue.Enqueue(new PathNode(source, distance[source]), distance[source]); while (queue.Count != 0) { PathNode pathNode = queue.Dequeue(); if (visit[pathNode.point]) { continue; //已计算 } visit[pathNode.point] = true; //k节点已遍历 for (int m = first[pathNode.point]; m != -1; m = next[m]) { if (value[m] + distance[pathNode.point] < distance[v[m]]) { distance[v[m]] = value[m] + distance[pathNode.point]; preCopy[v[m]] = pathNode.point; queue.Enqueue(new PathNode(v[m], value[v[m]]), value[v[m]]); } } } for (int i = 0; i < preCopy.Length; ++i) { pre[exitIndex, i] = preCopy[i]; } }
protected virtual T GetLowest() { return(OpenSet.Dequeue()); //var lowest = OpenSet[0]; //for (int i = 1; i < OpenSet.Count; i++) { // if (OpenSet[i].TotalCost < lowest.TotalCost) { // lowest = OpenSet[i]; // continue; // } // var totalDiff = Math.Abs(OpenSet[i].TotalCost - lowest.TotalCost); // if (totalDiff > Accuracy) { // continue; // } // var endDiff = Math.Abs(OpenSet[i].EndCost - lowest.EndCost); // if (endDiff > Accuracy) { // if (OpenSet[i].EndCost < lowest.EndCost) { // lowest = OpenSet[i]; // } // continue; // } // if (OpenSet[i].GetTravelCost(null, Start, End) < lowest.GetTravelCost(null, Start, End)) { // lowest = OpenSet[i]; // } //} //return lowest; }
/// <summary> /// Pops the item with the lowest priority off of the queue. /// </summary> public T Dequeue() { WrappedNode popped = _underlyingQueue.Dequeue(); _mapDataToWrappedNode.Remove(popped.data); return(popped.data); }
// Hay que resetear la Astar cada vez que se llame, reseatear todo las variables a valor del start public List <Vector2> calculatePath(int [,] tablero, Vector2 pathStart, Vector2 pathEnd) { fillMarked(tablero); fillTableroNode(tablero, pathEnd); tableroNode [(int)pathStart.x, (int)pathStart.y].g = 0; tableroNode [(int)pathStart.x, (int)pathStart.y].estado = Node.state.open; // referencia a un nodo que se va a considerar a continuacion Node myNode = tableroNode [(int)pathStart.x, (int)pathStart.y]; // Nodo que vamos a usar para guardar el nodo final Node aux = null; open.Enqueue(myNode, myNode.g); while (open.Count != 0) { myNode = open.Dequeue(); myNode.estado = Node.state.closed; marked [(int)myNode.pos.x, (int)myNode.pos.y] = true; aux = addNeighbours(myNode, pathEnd); if (aux != null) { open.Clear(); return(getPath(aux)); } } return(null); }
private List <Node> GetSamePrimKeys() { List <Node> samePrim = new List <Node>(); float firstPriority = fastOpenListPrim.First().Priority; while (fastOpenListPrim.Count > 0) { if (fastOpenListPrim.First().Priority <= firstPriority) { samePrim.Add(fastOpenListPrim.Dequeue()); } else { break; } } for (int i = 0; i < samePrim.Count; i++) { fastOpenListPrim.Enqueue(samePrim[i], samePrim[i].Priority); } if (fastOpenListPrim.Count == 0) { Debug.Log("empty open list"); } return(samePrim); }
public override IEnumerable <Node> AStar(Node from, Node to) { var openSet = new FastPriorityQueue <Node>(Width * Height); openSet.Enqueue(from, 0f); while (openSet.Count > 0) { var currentNode = openSet.Dequeue(); if (currentNode == to) { var path = ReconstructPath(currentNode); foreach (var node in this) { node.Reset(); } return(path); } currentNode.InClosedSet = true; foreach (var neighbor in currentNode.Neighbors) { if (neighbor.InClosedSet) { continue; } var tentativeGScore = currentNode.GScore + currentNode.Distance(neighbor); if (openSet.Contains(neighbor) && tentativeGScore >= neighbor.GScore) { continue; } neighbor.CameFrom = currentNode; neighbor.GScore = tentativeGScore; var fs = tentativeGScore + HeuristicCostEstimate(neighbor, to); if (openSet.Contains(neighbor)) { openSet.UpdatePriority(neighbor, fs); } else { openSet.Enqueue(neighbor, fs); } } } foreach (var node in this) { node.Reset(); } return(new List <Node>()); }
bool CollapseNextEdge() { if (PQ.Count == 0) { return(false); } FaceNode nextFace = PQ.Dequeue(); // If this face is already degenerate from another edge collapse, skip it. if (nextFace.face.Collapsed) { return(true); } Edge minEdge = OptimalEdge(nextFace.face); int v1 = minEdge.anyHalfEdge.tailVertex.Index; CollapseEdge(minEdge); // Update priorities around each merged vertex foreach (int v in uf.Find(v1).MergedPoints) { FixPQAroundVertex(heMesh.Vertices[v]); } return(true); }
public List <Vector2Int> FindPath(Vector2Int start, Vector2Int end) { if (!_grid.CanMove(start) || !_grid.CanMove(end)) { return(null); } _grid.Clear(); _start = start; _end = end; _openSet.Clear(); // 后面大括号内为 初始化列表 var startNode = new Jps_Node(_start) { Cost = 0, IsOpen = false, IsClose = false, IsForce = false }; _openSet.Enqueue(startNode, startNode.Cost); // 每次取 估值函数最小的节点 检测 while (_openSet.Count > 0) { Jps_Node cur = _openSet.Dequeue(); cur.IsClose = true; if (cur.Pos == _end) { return(Trace(cur)); } IdentitySuccessors(cur); } return(null); }
public void ProcessCircleEvent() { var p = circleQ.Dequeue().point; regionsT.ProcessCircleEvent(p); AddCreatedCircleEvents(); }
private void AStar(ByteVector2 from, ByteVector2 to) { // Initialize start node int initialHeuristic = EuclideanDistance(from, to); TileNode startNode = new TileNode(from.X, from.Y, 0, initialHeuristic); // Store start node nodeQueue.Enqueue(startNode, startNode.TotalCost); nodeTracker[startNode.Y, startNode.X] = startNode; // Run A* while (true) { if (nodeQueue.Count == 0) // If the queue is empty, exit and fail { break; } // Get the next best node TileNode bestNode = nodeQueue.Dequeue(); // Set closed state and break if dest. reached if (SetClosedState(bestNode)) { SetBestPath(bestNode); break; } // Scan all adjacent nodes AStarScanAdjacent(bestNode); } }
public Path GetShortestPath(string from, string to) { if (!_nodes.TryGetValue(from, out var fromNode)) { throw new Exception("from node not exist"); } if (!_nodes.TryGetValue(to, out var toNode)) { throw new Exception("to node not exist"); } var distances = new Dictionary <Node, int>(); foreach (var node in _nodes.Values) { distances.Add(node, int.MaxValue); } distances.Remove(fromNode); distances.Add(fromNode, 0); var visited = new HashSet <Node>(); var privouseNode = new Dictionary <Node, Node>(); var queue = new FastPriorityQueue <NodeEntry>(10); queue.Enqueue(node: new NodeEntry(fromNode, 0), priority: 0); while (queue.Any()) { var current = queue.Dequeue().GetNode(); visited.Add(current); foreach (var edge in current.GetEdges()) { var edgeTo = Get(edge.To()); if (visited.Contains(edgeTo)) { continue; } var newDistance = distances[current] + edge.GetWeight(); if (newDistance >= distances[edgeTo]) { continue; } distances.Remove(edgeTo); distances.Add(edgeTo, newDistance); if (privouseNode.TryGetValue(edgeTo, out var currentNode)) { privouseNode.Remove(edgeTo); } privouseNode.Add(edgeTo, current); queue.Enqueue(new NodeEntry(edgeTo, newDistance), newDistance); } } return(BuildPath(privouseNode, toNode)); }
private List <NavPath> Dijkstra(Node s) { Dictionary <long, QueueNode> touched = new Dictionary <long, QueueNode>(); HashSet <long> done = new HashSet <long>(); FastPriorityQueue <QueueNode> pq = new FastPriorityQueue <QueueNode>(map.Nodes.Count); List <NavPath> ret = Enumerable.Repeat(NavPath.NoPath, intersections.Count).ToList(); QueueNode start = new QueueNode(s.id); start.path = new NavPath(); touched[s.id] = start; pq.Enqueue(start, 0); while (pq.Count != 0) { QueueNode qn = pq.Dequeue(); float distance = qn.Priority; NavPath p = qn.path; Node n = map.Nodes[qn.id]; done.Add(n.id); ret[pathMapping[n.id]] = p; foreach (var edgeId in n.Edges) { Way edge = map.Ways[edgeId]; if (edge.GetNext(n.id) != -1) { Node next = map.Nodes[edge.GetNext(n.id)]; float newWeight = distance + edge.weight; if (!done.Contains(next.id)) { List <Vector3> points = new List <Vector3>(edge.waypoints); if (edge.isBack(n.id)) { points.Reverse(); } if (touched.ContainsKey(next.id)) { qn = touched[next.id]; if (qn.Priority > newWeight) { pq.UpdatePriority(qn, newWeight); qn.path = new NavPath(p.getPoints()); qn.path.Add(points); } } else { qn = new QueueNode(next.id); qn.path = new NavPath(p.getPoints()); qn.path.Add(points); touched[next.id] = qn; pq.Enqueue(qn, newWeight); } } } } } return(ret); }
private int GetShortestPathToTarget() { var visitedPoints = new Dictionary <Point, HashSet <EquipmentType> >(); var consideredPoints = new FastPriorityQueue <PointNode>((this._furthestPoint.X + 1) * (this._furthestPoint.Y + 1) * 3); consideredPoints.Enqueue(new PointNode { P = new Point(0, 0), Time = 0, Equipment = EquipmentType.Torch }, 0); while (consideredPoints.Any()) { var consideredPoint = consideredPoints.Dequeue(); if (!visitedPoints.ContainsKey(consideredPoint.P)) { visitedPoints.Add(consideredPoint.P, new HashSet <EquipmentType> { consideredPoint.Equipment }); } else { if (visitedPoints[consideredPoint.P].Contains(consideredPoint.Equipment)) { continue; } visitedPoints[consideredPoint.P].Add(consideredPoint.Equipment); } if (consideredPoint.P == this._targetPosition) { if (consideredPoint.Equipment == EquipmentType.Torch) { return(consideredPoint.Time); } var nextPoint = new PointNode { P = consideredPoint.P, Equipment = EquipmentType.Torch, Time = consideredPoint.Time + 7 }; consideredPoints.Enqueue(nextPoint, nextPoint.Time); } var neighbours = this.GetNextPoints(consideredPoint, visitedPoints); foreach (var neighbour in neighbours) { consideredPoints.Enqueue(neighbour, neighbour.Time); } } return(int.MaxValue); }
public void ProcessPointEvent() { var p = eventQ.Dequeue().point; var pointAsEvent = new SiteEvent(p.basepoint); regionsT.AddToBeachLine(pointAsEvent); AddCreatedCircleEvents(); }
/// <summary> /// Wyszukuje najkrótszą ścieżkę pomiędzy dwoma polami. /// Implementacja algorytmu A*. /// </summary> /// <param name="fields">Tablica pól z zadeklarowną dostępnością. Muszą dziedziczyć po klasie PathFindableField</param> /// <param name="start">Pole startowe</param> /// <param name="destination">Pole końcowe</param> /// <param name="minIndexLimit">Minimalne indeksy pól branych pod uwagę przy wyznaczaniu ścieżki</param> /// <param name="maxIndexLimit">Maksymalne indeksy pól branych pod uwagę przy wyznaczaniu ścieżki</param> /// <seealso cref="PathFindableField"/> /// <exception cref="ArgumentNullException" /> /// <exception cref="ArgumentOutOfRangeException" /> /// <returns>Najkrótsza ścieżka (stos)</returns> internal static Stack <Vector2Int> FindPath(bool[][] fields, Vector2Int start, Vector2Int destination, Vector2Int minIndexLimit, Vector2Int maxIndexLimit) { #if DEBUG CheckArguments(fields, start, destination, minIndexLimit, maxIndexLimit); #endif var openSet = new FastPriorityQueue <AStarPosition>((maxIndexLimit.x - minIndexLimit.x) * (maxIndexLimit.y - minIndexLimit.y)); var startNode = new AStarNode(); InitializeAstarNodes(fields, out AStarNode[][] nodes); InitializeParents(fields, out Vector2Int[][] parents); AddToOpenSet(openSet, nodes, startNode, start); while (openSet.Count > 0) { var actualNodePosition = openSet.Dequeue(); // znaleziono ścieżkę if (actualNodePosition.position == destination) { return(CombinePath(actualNodePosition.position, start, nodes, parents)); } AddToClosedSet(nodes, actualNodePosition.position); foreach (var neighborPosition in GetNeighbors(fields, nodes, actualNodePosition.position, minIndexLimit, maxIndexLimit)) { if (IsInClosedSet(neighborPosition, nodes)) { continue; } var actualG = nodes[actualNodePosition.position.x][actualNodePosition.position.y].g + 1; if (IsInOpenSet(neighborPosition, nodes)) { var neighbor = nodes[neighborPosition.x][neighborPosition.y]; if (actualG < neighbor.g) { parents[neighborPosition.x][neighborPosition.y] = actualNodePosition.position; neighbor.g = actualG; openSet.UpdatePriority(actualNodePosition, neighbor.F); } } else { parents[neighborPosition.x][neighborPosition.y] = actualNodePosition.position; nodes[neighborPosition.x][neighborPosition.y].g = actualG; nodes[neighborPosition.x][neighborPosition.y].h = HexHelper.GetDistance(neighborPosition, destination); nodes[neighborPosition.x][neighborPosition.y].state = AStarNode.States.InOpenSet; openSet.Enqueue(new AStarPosition(neighborPosition), nodes[neighborPosition.x][neighborPosition.y].F); } } } return(new Stack <Vector2Int>()); }
void FindPath(Vector3 a_StartPos, Vector3 a_TargetPos) { Node StartNode = nodeMesh.NodeFromWorldPoint(a_StartPos); //Gets the node closest to the starting position Node TargetNode = nodeMesh.NodeFromWorldPoint(a_TargetPos); //Gets the node closest to the target position if (StartNode != null && TargetNode != null) { FastPriorityQueue <Node> OpenList = new FastPriorityQueue <Node>(200); //SimplePriorityQueue<Node> OpenList = new FastPriorityQueue<Node>(maxN_Calculations);//List of nodes for the open list HashSet <Node> ClosedList = new HashSet <Node>(); //Hashset of nodes for the closed list OpenList.Enqueue(StartNode, StartNode.FCost); //Add the starting node to the open list to begin the program while (OpenList.Count > 0) //Whilst there is something in the open list { Node CurrentNode = OpenList.Dequeue(); //Create a node and set it to the first item in the open list OpenList.ResetNode(CurrentNode); //OpenList.Remove(CurrentNode);//Remove that from the open list ClosedList.Add(CurrentNode); //And add it to the closed list if (CurrentNode == TargetNode) //If the current node is the same as the target node { GetFinalPath(StartNode, TargetNode); //Calculate the final path } //Debug.Log("el nodo en cuestion tiene x vecinos" + CurrentNode.NeighbNodes.Count); Node[] nNodes = nodeMesh.GetNeighbNodes(CurrentNode); for (int i = 0; i < nNodes.Length; i++) { Node NeighborNode = nNodes[i]; if (NeighborNode == null) { continue; } if (NeighborNode.BIsWall || ClosedList.Contains(NeighborNode)) { continue; //If the neighbor is a wall or has already been checked // Skip it } int MoveCost = CurrentNode.IgCost + GetManhattenDistance(CurrentNode, NeighborNode); //Get the F cost of that neighbor if (MoveCost < NeighborNode.IgCost || !OpenList.Contains(NeighborNode)) //If the f cost is greater than the g cost or it is not in the open list { NeighborNode.IgCost = MoveCost; //Set the g cost to the f cost NeighborNode.IhCost = GetManhattenDistance(NeighborNode, TargetNode); //Set the h cost NeighborNode.ParentNode1 = CurrentNode; //Set the parent of the node for retracing steps if (!OpenList.Contains(NeighborNode)) //If the neighbor is not in the openlist { //Add it to the list OpenList.Enqueue(NeighborNode, NeighborNode.FCost); } } } } //while (OpenList.Count > 0) //{ // OpenList.ResetNode(OpenList.Dequeue()); //} } }
private static int FindShortestPathTime(int[,] erosionLevelMap, int x, int y, int equip, int time) { var queue = new FastPriorityQueue <State>(100000); var set = new HashSet <(int, int, int)>(); queue.Enqueue(new State(x, y, equip), time); while (true) { var state = queue.Dequeue(); time = (int)state.Priority; x = state.X; y = state.Y; equip = state.Equip; if (x == TARGET_X && y == TARGET_Y && equip == TORCH) { return(time); } if (set.Contains((x, y, equip))) { continue; } set.Add((x, y, equip)); for (int newEquip = 0; newEquip < 3; newEquip++) { if (CorrectEquipForRegionType(newEquip, GetRegionType(erosionLevelMap[x, y]))) { queue.Enqueue(new State(x, y, newEquip), (time + 7)); } } for (int direction = 0; direction < 4; direction++) { int dx, dy; (dx, dy) = GetDirectionVector(direction); if (x + dx >= DIMENSION_X || x + dx < 0 || y + dy >= DIMENSION_Y || y + dy < 0) { continue; } if (CorrectEquipForRegionType(equip, GetRegionType(erosionLevelMap[x + dx, y + dy]))) { queue.Enqueue(new State(x + dx, y + dy, equip), (time + 1)); } } } }
public override bool Find(DirectionGraph graph, Node start, Node end) { priorityQueue = new FastPriorityQueue <Node>(graph.VerticeCount()); searchSteps = new Queue <Node>(); System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch(); watch.Start(); costForStartToTarget = new Dictionary <Node, int>(); costForStartToTarget[start] = 0; priorityQueue.Enqueue(start, 0); while (priorityQueue.Count > 0) { Node min = priorityQueue.Dequeue(); if (min == end) { watch.Stop(); executionTimes = watch.Elapsed.TotalMilliseconds; CalculateCostAndGeneratePath(start, end, graph); return(true); } List <DirectionEdge> minNeighbors = graph.GetNeighborEdge(min); int costForStartToMin = costForStartToTarget[min]; for (int i = 0, count = minNeighbors.Count; i < count; i++) { Node neighbor = minNeighbors[i].to; int costForStartToNeighbor = int.MaxValue; if (costForStartToTarget.ContainsKey(neighbor)) { costForStartToNeighbor = costForStartToTarget[neighbor]; } int newCostSoFar = costForStartToMin + minNeighbors[i].weight; if (newCostSoFar < costForStartToNeighbor) { costForStartToTarget[neighbor] = newCostSoFar; nodesComeFrom[neighbor] = min; if (priorityQueue.Contains(neighbor)) { priorityQueue.UpdatePriority(neighbor, newCostSoFar); } else { priorityQueue.Enqueue(neighbor, newCostSoFar); } } } if (min != start) { searchSteps.Enqueue(min); } } watch.Stop(); executionTimes = watch.Elapsed.TotalMilliseconds; searchSteps.Clear(); return(false); }
public static void GetNextReminder() { if (reminderQueue != null && reminderQueue.Count != 0) { Console.WriteLine("MEMORY QUEUE IS NOT EMPTY"); reminderHolder = reminderQueue.Dequeue(); Console.WriteLine(reminderQueue.Count); } }
public Node NextOpen() { Node node = open.Dequeue(); opened[node.pos.x, node.pos.y] = null; closed[node.pos.x, node.pos.y] = true; return(node); }
private static State Solve(Problem problem, out int totalScore) { int timeLeft = problem.DayCount; totalScore = 0; var state = new State(); var bookIDsAdded = new HashSet <int>(); var libraryQueue = new FastPriorityQueue <Library>(problem.Libraries.Length); var idsOfLibrariesToSignUp = new HashSet <int>(); foreach (var library in problem.Libraries) { float score = GetPotentialScore(problem, library, bookIDsAdded, timeLeft); if (score > 0) { libraryQueue.Enqueue(library, -score); idsOfLibrariesToSignUp.Add(library.ID); } } while (libraryQueue.Count != 0) { var library = libraryQueue.Dequeue(); idsOfLibrariesToSignUp.Remove(library.ID); if (library.SignUpTime < timeLeft) { var signUp = new SignUp { LibraryID = library.ID, }; AddBooks(problem, signUp, timeLeft, bookIDsAdded, out int scoreForLibrary); if (scoreForLibrary > 0) { state.SignUps.Add(signUp); timeLeft -= library.SignUpTime; totalScore += scoreForLibrary; foreach (var libraryToSignUp in idsOfLibrariesToSignUp.Select(id => problem.Libraries[id]).ToArray()) { float score = GetPotentialScore(problem, libraryToSignUp, bookIDsAdded, timeLeft); if (score == 0) { libraryQueue.Remove(libraryToSignUp); idsOfLibrariesToSignUp.Remove(libraryToSignUp.ID); } else { libraryQueue.UpdatePriority(libraryToSignUp, -score); } } } } } return(state); }
public void TestIntQueuePriority() { FastPriorityQueue <Node> fastQueue = new FastPriorityQueue <Node>(100); for (int i = 1; i < 50; i++) { fastQueue.Enqueue(new Node(), i * 2); } Node n = new Node(); n.Name = "Test"; fastQueue.Enqueue(n, 2.0f); fastQueue.Enqueue(new Node(), -1.0f); Assert.IsTrue(fastQueue.First.Priority == -1.0f); Assert.IsFalse(fastQueue.First.Name == "Test"); fastQueue.Dequeue(); fastQueue.Dequeue(); Assert.IsTrue(fastQueue.First.Name == "Test"); }
static void TestCase2() { var random = new Random(); var myHeap = new BinomialHeap<double>(double.MinValue, Comparer<double>.Default); var otherQueue = new FastPriorityQueue<FastPriorityQueueNode>(10000); for (var i = 0; i < 10000; i++) { if (otherQueue.Any() && random.Next(3) == 0) { Assert(Math.Abs(myHeap.ExtractMin().Item2 - otherQueue.Dequeue().Priority) < double.Epsilon); } else { var newValue = random.NextDouble()*10; myHeap.Insert(newValue); otherQueue.Enqueue(new FastPriorityQueueNode(), newValue); } } while(otherQueue.Any()) Assert(Math.Abs(myHeap.ExtractMin().Item2 - otherQueue.Dequeue().Priority) < double.Epsilon); }
public static void RunExample() { //First, we create the priority queue. We'll specify a max of 10 users in the queue FastPriorityQueue<User> priorityQueue = new FastPriorityQueue<User>(MAX_USERS_IN_QUEUE); //Next, we'll create 5 users to enqueue User user1 = new User("1 - Jason"); User user2 = new User("2 - Tyler"); User user3 = new User("3 - Valerie"); User user4 = new User("4 - Joseph"); User user42 = new User("4 - Ryan"); //Now, let's add them all to the queue (in some arbitrary order)! priorityQueue.Enqueue(user4, 4); priorityQueue.Enqueue(user2, 0); //Note: Priority = 0 right now! priorityQueue.Enqueue(user1, 1); priorityQueue.Enqueue(user42, 4); priorityQueue.Enqueue(user3, 3); //Change user2's priority to 2. Since user2 is already in the priority queue, we call UpdatePriority() to do this priorityQueue.UpdatePriority(user2, 2); //Finally, we'll dequeue all the users and print out their names while(priorityQueue.Count != 0) { User nextUser = priorityQueue.Dequeue(); Console.WriteLine(nextUser.Name); } //Output: //1 - Jason //2 - Tyler //3 - Valerie //4 - Joseph //4 - Ryan //Notice that when two users with the same priority were enqueued, they were dequeued in the same order that they were enqueued. }
public void WriteMIDI(string path) { HashSet<Note>.Enumerator enumerator = notes.GetEnumerator(); FastPriorityQueue<Note> startQueue = new FastPriorityQueue<Note>(numNotes); FastPriorityQueue<Note> endQueue = new FastPriorityQueue<Note>(numNotes); while (enumerator.MoveNext()) { startQueue.Enqueue(enumerator.Current, enumerator.Current.Priority); } using (BinaryWriter writer = new BinaryWriter(File.Open(path+trackName + ".mid", FileMode.Create))) { writer.Write(OneTrackHeader()); writer.Write(StandardTrackHeader()); long deltaStart = 0; do { if (endQueue.Peek() == null) { Note note = startQueue.Dequeue(); writer.Write(note.MidiStart(deltaStart)); deltaStart = (long) note.Priority; endQueue.Enqueue(note, note.Priority+note.GetDuration()); } else if (startQueue.Peek() == null) { Note note = endQueue.Dequeue(); writer.Write(note.MidiEnd(deltaStart)); deltaStart = (long) note.Priority; } else { if (endQueue.Peek().Priority > startQueue.Peek().Priority) { Note note = startQueue.Dequeue(); writer.Write(note.MidiStart(deltaStart)); deltaStart = (long)note.Priority; endQueue.Enqueue(note, note.Priority+note.GetDuration()); } else { Note note = endQueue.Dequeue(); writer.Write(note.MidiEnd(deltaStart)); deltaStart = (long)note.Priority; } } } while (startQueue.Count + endQueue.Count > 0); writer.Write(TrackEnd()); } }