public virtual AstarNode <T> Solve(AstarNode <T> Root, params object[] args) { IntervalHeap <AstarNode <T> > ih = new IntervalHeap <AstarNode <T> >(); ih.Add(Root); AstarNode <T> curNode; bool add; while (ih.Count > 0) { curNode = ih.DeleteMin(); curNode.Expand(args); if (curNode.Completed(args)) { return(curNode); } if (curNode.Children.Count > 0) { foreach (var node in curNode.Children) { if (node.CanAdd()) { ih.Add(node); added++; } total++; } } } return(null); }
/// <summary> /// Sorts the vertices in topological order /// </summary> /// <returns>List of topological sorted vertices</returns> public List <Vertex> TopologicalSort(ColumnChanges columnChanges) { IPriorityQueue <Vertex> priorityQueue = new IntervalHeap <Vertex>(new VerticesComparer(Options, columnChanges)); var sortedVertices = new List <Vertex>(); var incomingEdges = new Dictionary <Vertex, int>(); foreach (var v in Vertices) { incomingEdges[v] = v.IngoingEdges().Count; if (incomingEdges[v] == 0) { priorityQueue.Add(v); } } while (!priorityQueue.IsEmpty) { Vertex v = priorityQueue.FindMin(); sortedVertices.Add(v); priorityQueue.DeleteMin(); foreach (var e in v.OutgoingEdges()) { incomingEdges[e.Destination]--; if (incomingEdges[e.Destination] == 0) { priorityQueue.Add(e.Destination); } } } return(sortedVertices); }
public void Replace5b() { for (var size = 0; size < 130; size++) { IPriorityQueue <double> q = new IntervalHeap <double>(); IPriorityQueueHandle <double> handle1 = null; q.Add(ref handle1, -3.0); Assert.AreEqual(-3.0, q.FindMax()); for (var i = 1; i < size; i++) { q.Add(-i - 3.0); } Assert.AreEqual(-3.0, q.FindMax()); for (var max = -2; max <= 10; max++) { Assert.AreEqual(max - 1.0, q.Replace(handle1, max)); Assert.AreEqual(max, q.FindMax()); } Assert.AreEqual(10.0, q.DeleteMax()); for (var i = 1; i < size; i++) { Assert.AreEqual(-i - 3.0, q.DeleteMax()); } Assert.IsTrue(q.IsEmpty); } }
/// <summary> /// The Interval heap used in this method represents the min heap /// required form the last sub task of task 7.37. /// </summary> /// <param name="array"></param> /// <param name="kSmallestElement"></param> /// <returns></returns> public int FindKthSmallestElementUsingMinHeap(int[] array, int kSmallestElement) { var n = array.Length; if (n - 1 < kSmallestElement) { return(int.MinValue); } IntervalHeap <int> intervalHeap = new IntervalHeap <int>(); for (int i = 0; i < n; i++) { if (intervalHeap.Count < kSmallestElement) { intervalHeap.Add(array[i]); } else { if (intervalHeap.FindMax() > array[i]) { intervalHeap.DeleteMax(); intervalHeap.Add(array[i]); } } } for (int i = 0; i < kSmallestElement - 1; i++) { intervalHeap.DeleteMin(); } return(intervalHeap.FindMin()); }
public void Bug20130208() { IPriorityQueue <double> q = new IntervalHeap <double>(); IPriorityQueueHandle <double> h0 = null, h2 = null, h4 = null, h7 = null, h5 = null; // Add(43, 0); q.Add(ref h0, 43); // Remove(); q.DeleteMin(); // XAddMaxReplace(9, 2); q.Add(ref h2, Double.MaxValue); q[h2] = 9; // XAddMaxReplace(32, 4); q.Add(ref h4, Double.MaxValue); q[h4] = 32; // XAddMaxReplace(44, 7); q.Add(ref h7, Double.MaxValue); q[h7] = 44; // Remove(); q.DeleteMin(); // XAddMaxReplace(0, 5); q.Add(ref h5, Double.MaxValue); q[h5] = 0; // Internally inconsistent data structure already now Assert.IsTrue(q.Check()); }
public ListNode mergeKLists(List <ListNode> a) { if (a == null || a.Count == 0) { return(null); } var pq = new IntervalHeap <ListNode>(); foreach (var ln in a) { if (ln != null) { pq.Add(ln); } } var head = new ListNode(0); var p = head; while (pq.Count > 0) { var t = pq.DeleteMin(); p.next = t; p = p.next; if (t.next != null) { pq.Add(t.next); } } return(head.next); }
private void GetTopDistances(IEnumerable <string> threadDictionary) { var comparer = new WordDistanceComparer(); var heap = new IntervalHeap <WordDistance>(HeapCapacity, comparer); foreach (var entry in threadDictionary) { var threshold = heap.Any() ? heap.FindMax().Distance : int.MaxValue; var distance = Value.GetDistance(entry, threshold); if (heap.Count < HeapCapacity) { heap.Add(new WordDistance(entry, distance)); continue; } if (distance >= threshold) { continue; } heap.DeleteMax(); heap.Add(new WordDistance(entry, distance)); } foreach (var wordDistance in heap) { results.Add(wordDistance); } }
public static List <Point> FindClosestPoints(Point[] points, int k) { IPriorityQueue <Point> maxHeap = new IntervalHeap <Point>(); // new IPriorityQueueHandle<Point>((p1, p2) => p2.distFromOrigin() - p1.distFromOrigin()); // put first 'k' points in the max heap for (int i = 0; i < k; i++) { maxHeap.Add(points[i]); } // go through the remaining points of the input array, if a point is closer to // the origin than the top point of the max-heap, remove the top point from // heap and add the point from the input array for (int i = k; i < points.Length; i++) { if (points[i].distFromOrigin() < maxHeap.Max().distFromOrigin()) { maxHeap.DeleteMax(); maxHeap.Add(points[i]); } } //Point x = new Point(k, 0); // the heap has 'k' points closest to the origin, return them in a list return(maxHeap.ToList <Point>()); }
public void Replace5a() { for (var size = 0; size < 130; size++) { IPriorityQueue <double> q = new IntervalHeap <double>(); IPriorityQueueHandle <double> handle1 = null; q.Add(ref handle1, 3.0); Assert.AreEqual(3.0, q.FindMin()); for (var i = 1; i < size; i++) { q.Add(i + 3.0); } Assert.AreEqual(3.0, q.FindMin()); for (var min = 2; min >= -10; min--) { Assert.AreEqual(min + 1.0, q.Replace(handle1, min)); Assert.AreEqual(min, q.FindMin()); } Assert.AreEqual(-10.0, q.DeleteMin()); for (var i = 1; i < size; i++) { Assert.AreEqual(i + 3.0, q.DeleteMin()); } Assert.IsTrue(q.IsEmpty); } }
private void HandleSiteEvent(SiteEvent siteEvent) { EventTree.TreeNode node = _eventTree.GetClosest(this, _eventTree.GetRoot(), siteEvent); if (node == null || node is EventTree.BreakpointNode) { return; } EventTree.LeafNode closest = (EventTree.LeafNode)node; if (closest.GetDisappearEvent() != null) { _eventQueue.Delete(closest.GetDisappearEvent().GetHandle()); closest.SetDisappearEvent(null); } List <CircleEvent> circleEvents2 = _eventTree.InsertNewSiteEvent(closest, new TreeItem(siteEvent.V())); foreach (var ce in circleEvents2) { IPriorityQueueHandle <IEvent> h = null; _eventQueue.Add(ref h, ce); ce.SetHandle(h); } }
public override void Update(Pose goal) { bool[,] expanded = new bool[grid.NumColumns, grid.NumRows]; LinkedList <GridCell>[,] memoized = new LinkedList <GridCell> [grid.NumColumns, grid.NumRows]; GridCell startCell = grid.PointToCellPosition(goal.Position); IntervalHeap <GridCellValue> open = new IntervalHeap <GridCellValue>(); for (int c = 0; c < grid.NumColumns; c++) { for (int r = 0; r < grid.NumRows; r++) { heuristic[c, r] = float.PositiveInfinity; expanded[c, r] = false; } } heuristic[startCell.C, startCell.R] = 0f; open.Add(new GridCellValue(startCell, 0f)); while (!open.IsEmpty) { GridCell cell = open.DeleteMin().Position; expanded[cell.C, cell.R] = true; LinkedList <GridCell> neighbors = memoized[cell.C, cell.R]; if (neighbors == null) { neighbors = grid.Get8Neighbors(cell); memoized[cell.C, cell.R] = neighbors; } foreach (GridCell n in neighbors) { if (expanded[n.C, n.R]) { continue; } if (grid.OccupiedCells[n.C, n.R] > 0) { continue; } if (grid.GVD.GetObstacleDistance(n) <= Car.HALF_CAR_WIDTH) { continue; } float dist = cell.C == n.C || cell.R == n.R ? 1f : sqrt2; dist += heuristic[cell.C, cell.R]; if (dist < heuristic[n.C, n.R]) { heuristic[n.C, n.R] = dist; open.Add(new GridCellValue(n, dist)); } } } }
/* * This method creates the workers */ public void CreateWorkers() // This method creates workers { for (int i = 0; i < numberOfWorkers; i++) { Worker worker = new Worker("Worker" + (i + 1)); workersHeap.Add(worker); } }
private void setVoro(GridCell s) { nearestVoro[s.C, s.R] = s; voroDist[s.C, s.R] = 0; voroDistActual[s.C, s.R] = 0f; voroOpen.Add(new GridCellValue(s, 0)); voroToProcess[s.C, s.R] = true; }
public void getMovementPaths(Vector2 startPosition, int moveDistance, bool highlight) { //Get no go areas from player controllers var unitPositions = Controller.getUnitPositions(); // Pathfinding stuff IntervalHeap <PathfinderNode> frontier = new IntervalHeap <PathfinderNode>(new PathfinderNode(new Vector2(), 0)); frontier.Add(new PathfinderNode(startPosition, 0)); Dictionary <Vector2, Vector2> cameFrom = new Dictionary <Vector2, Vector2>(); Dictionary <Vector2, int> costSoFar = new Dictionary <Vector2, int>(); cameFrom.Add(startPosition, new Vector2(-1, -1)); costSoFar.Add(startPosition, 0); while (frontier.Count > 0) { //Get current PathfinderNode current = frontier.FindMin(); frontier.DeleteMin(); // iterate through neighbours foreach (Vector2 next in map.getNeibour(current.position)) { if (unitPositions.Contains(next)) { continue; } int newCost = map.tileTypes[map.tiles[(int)next.x, (int)next.y]].cost + costSoFar[current.position]; if (newCost <= moveDistance && (!costSoFar.ContainsKey(next) || newCost < costSoFar[next])) { int priority = newCost; if (costSoFar.ContainsKey(next)) { costSoFar[next] = newCost; PathfinderNode newNode = new PathfinderNode(next, priority); frontier.Add(newNode); cameFrom[next] = current.position; } else { costSoFar.Add(next, newCost); PathfinderNode newNode = new PathfinderNode(next, priority); frontier.Add(newNode); cameFrom.Add(next, current.position); } } } } if (highlight) { map.highlightArea(new List <Vector2>(costSoFar.Keys), new Color(0, 1, 1)); } pathingData = cameFrom; }
public void PriorityMinEdgeFindsFirst() { IPriorityQueue <WeightedEdge <int> > queue = new IntervalHeap <WeightedEdge <int> >(); queue.Add(new WeightedEdge <int>(0, 1, 1)); queue.Add(new WeightedEdge <int>(1, 2, Double.PositiveInfinity)); Assert.AreEqual(new WeightedEdge <int>(0, 1, 1), queue.FindMin()); }
public void SetObstacle(GridCell s, int obstId) { obst[s.C, s.R] = s; comp[s.C, s.R] = obstId; dist[s.C, s.R] = 0; distActual[s.C, s.R] = 0f; open.Add(new GridCellValue(s, 0)); toProcess[s.C, s.R] = true; }
public void SetObstacle(GridCell cell, int obstacleId) { distNew[cell.C, cell.R] = 0f; obst[cell.C, cell.R] = obstacleId; parent[cell.C, cell.R] = cell; valid.Add(obstacleId); open.Add(new GridCellValue(cell, 0f)); }
private static List <string> BFSPhase3(string toFind, Dictionary <string, List <string> > newGraph, string startPoint) { var q = new IntervalHeap <string>(); var distTo = new Dictionary <string, int>(); var edgeTo = new Dictionary <string, string>(); var marked = new Dictionary <string, bool>(); //We just start at the first node q.Add(startPoint); //We now just keep track of occurrences //Should be two consecutive nodes? This does not do that currently //Unsure of examples where this would fail distTo.Add(startPoint, 0); marked.Add(startPoint, true); var counter = 0; while (!q.IsEmpty) { var v = q.DeleteMin(); foreach (var w in newGraph[v]) { if (w.Equals(toFind)) { counter++; } var mark = false; if (marked.ContainsKey(w)) { mark = marked[w]; } if (!mark) { marked[w] = true; distTo[w] = distTo[v] + 1; edgeTo[w] = v; q.Add(w); } } } var path = new List <string>(); var gotThere = marked[toFind]; if (gotThere) { string x; for (x = toFind; distTo[x] != 0; x = edgeTo[x]) { path.Add(x); } path.Add(x); } //Now path should contain the shortest possible path; //Is not part of a cycle return(path); }
public void findGreatestDiff(State state) //O(n^3) { int chosenX = 0; //city x to city y int chosenY = 0; double greatestDiff = double.NegativeInfinity; //initialize to -oo to find what the greatest //difference is List <PointF> points = new List <PointF>(); for (int i = 0; i < state.getMap().GetLength(0); i++) //rows, O(n) { for (int j = 0; j < state.getMap().GetLength(1); j++) //columns { if (state.getPoint(i, j) == 0) //if point is 0 { points.Add(new PointF(i, j)); //store all 0's in a point array } } } for (int i = 0; i < points.Count; i++) //loop through 0's to find the greatest difference { //O(n^3) there will be atmost n points, because the entire //matrix will be 0 int possibleMax = findExcludeMinusInclude(Convert.ToInt32(points[i].X), Convert.ToInt32(points[i].Y), state); //O(n^2) if (possibleMax >= greatestDiff) //set the point to point values, if it is 0 is covered by = { chosenX = Convert.ToInt32(points[i].X); chosenY = Convert.ToInt32(points[i].Y); greatestDiff = possibleMax; } } State include = makeInclude(chosenX, chosenY, state); //O(n^2) if (BSSF > include.getLB()) //if include's lowerbound is better than the BSSF { include.setEdge(chosenX, chosenY); //set the edge in the dictionary checkCycles(include, chosenX, chosenY); //O(n), make sure there are no potential cycles queue.Add(include); //add to the queue to be popped off later } if (isDictionaryFilled(include)) //O(n), have all of the edges been filled? then the include.LB is better { //than the current BSSF, set the BSSF BSSF = include.getLB(); bestState = include; //save the "bestState" } State exclude = makeExclude(chosenX, chosenY, state); //O(n^2) if (BSSF > exclude.getLB()) //if exclude's lowerbound is than the BSSF, add it to the queue { queue.Add(exclude); } if (isDictionaryFilled(exclude)) //O(n), have all of the edges been filled? { // then exclude's lowerbound is better, set the BSSF to exclude.LB BSSF = exclude.getLB(); bestState = exclude; } }
public CostCounter ExactSearch(double[] ts, out IndexFileDist bsf) { CostCounter meas = new CostCounter(0, 0); IntervalHeap <IndexEntryDist> pq = new IntervalHeap <IndexEntryDist>(NumIndexEntries); // approx search TermEntry approx = ApproximateSearch(ts); bsf = Index <DATAFORMAT> .MinFileEucDist(ts, approx.FileName); meas.IO++; meas.distance += approx.NumTimeSeries; // initalize pq with IndexEntries at root node foreach (IndexEntry e in index.Values) { pq.Add(new IndexEntryDist(e, Sax.MinDistPAAToiSAX( Sax.SaxStrToSaxVals(e.SaxWord), options.SaxOpts, ts))); } while (!pq.IsEmpty) { IndexEntryDist minInfo = pq.DeleteMin(); IndexEntry minEntry = minInfo.entry; if (minInfo.dist >= bsf.distance) { break; } if (minEntry is TermEntry) { IndexFileDist posMin = Index <DATAFORMAT> .MinFileEucDist(ts, ((TermEntry)minEntry).FileName); meas.IO++; meas.distance += minEntry.NumTimeSeries; // update bsf if (posMin.distance < bsf.distance) { bsf = posMin; } } else if (minEntry is SplitEntry <DATAFORMAT> ) { SplitEntry <DATAFORMAT> sEntry = minEntry as SplitEntry <DATAFORMAT>; foreach (IndexEntry e in sEntry.GetIndexEntries()) { pq.Add(new IndexEntryDist(e, Sax.MinDistPAAToiSAX( Sax.SaxStrToSaxVals(e.SaxWord), sEntry.Options.SaxOpts, ts))); } } } return(meas); }
public static PathfindingResult FindPath(this Unit unit, Field destination) { if (unit.Location == destination) { return(new PathfindingResult(null, false)); } var counter = 0; bool success = false; var start = unit.Location; var frontier = new IntervalHeap <FrontierElement>(new FrontierElement.Comparer()); var cameFrom = new Dictionary <Field, Field>(); var costSoFar = new Dictionary <Field, int>(); frontier.Add(new FrontierElement(0, start)); cameFrom.Add(start, null); costSoFar.Add(start, 0); while (!frontier.IsEmpty && counter < 150) { counter++; var current = frontier.DeleteMin(); if (current.Field == destination) { success = true; break; } foreach (var neighbour in current.Field.Neighbours) { var movement = unit.MovementAvailability(current.Field, neighbour); if (movement.Type != MovementType.Free) { continue; } var newCost = movement.Cost; newCost += costSoFar[current.Field]; if (!costSoFar.ContainsKey(neighbour) || newCost < costSoFar[neighbour]) { costSoFar[neighbour] = newCost; var priority = neighbour.DistanceTo(destination) + newCost; frontier.Add(new FrontierElement(priority, neighbour)); cameFrom[neighbour] = current.Field; } } } return(new PathfindingResult( path: success ? GetPath(cameFrom, destination) : null, success: success )); }
public void Bug20130208Case3() { // Case 3: only left.first IPriorityQueue <double> q = new IntervalHeap <double>(); IPriorityQueueHandle <double> topRight = null; q.Add(20); q.Add(ref topRight, 30); q.Add(25); q[topRight] = 10; Assert.IsTrue(q.Check()); Assert.IsTrue(q.FindMax() == 25); }
public Battle(IActor[] actors, int length = 180, int num_enemies = 1) { Actors = actors; Friendlies = actors; FightLength = length * 1000; _logger.Debug("Fight length: {0}", FightLength); Time = 0; TickOffset = new Random().Next(0, 3000); _logger.Debug("Tick offset: {0}", TickOffset); foreach (IActor actor in actors) { _logger.Debug("Actor added: [{0}] {1}", actor.JobID.ToString(), actor.Name); } // Initialize enemies. Enemies = new ITarget[num_enemies]; for (int i = 0; i < num_enemies; i++) { Enemies[i] = new StrikingDummy(); _logger.Debug("Enemy added: {0}", Enemies[i].Name); } Targets = Friendlies.ToList().Concat(Enemies.ToList()).ToArray(); EventQueue = new IntervalHeap <BattleEvent>(); EventLog = new ArrayList <CombatLogEvent>(); // Add the inital Actor decisions to the queue. These should drive the rest of the // simulation. foreach (IActor actor in Actors) { EventQueue.Add(new BattleEvent(BattleEventType.ACTOR_READY, Time, actor)); } // Event to signal the end of the fight. EventQueue.Add(new BattleEvent(BattleEventType.FIGHT_COMPLETE, FightLength)); // Event to signal the next Aura tick. EventQueue.Add(new BattleEvent(BattleEventType.AURA_TICK, Time + TickOffset)); if (TickOffset > 1500) { EventQueue.Add(new BattleEvent(BattleEventType.REGEN_TICK, 1500 - TickOffset)); } else { EventQueue.Add(new BattleEvent(BattleEventType.REGEN_TICK, TickOffset + 1500)); } }
private static void addNodeToMap(Node node) { //implement Dijkstra alghoritm: IntervalHeap <NodeEntry> sortedNodes = new IntervalHeap <NodeEntry>(); HashDictionary <Node, NodeEntry> hashedNodes = new HashDictionary <Node, NodeEntry>(); NodeEntry thisNode = new NodeEntry(); thisNode.Node = node; bool firstAdded = sortedNodes.Add(ref thisNode.Handle, thisNode); Debug.Assert(firstAdded); hashedNodes.Add(node, thisNode); while (sortedNodes.Count != 0) { NodeEntry currentNode = sortedNodes.DeleteMin(); foreach (Link link in currentNode.Node.NetworkInterfaces.Interfaces.Keys) { //get the node from the second side of link Node secondNode = (link.LinkSides[0].ConnectedNode == currentNode.Node) ? link.LinkSides[1].ConnectedNode : link.LinkSides[0].ConnectedNode; double distance = link.Metric + currentNode.Distance; if (hashedNodes.Contains(secondNode)) { NodeEntry entry = hashedNodes[secondNode]; if (entry.Distance > distance) { entry.Distance = distance; sortedNodes.Replace(entry.Handle, entry); } } else { NodeEntry newEntry = new NodeEntry(); newEntry.Node = secondNode; newEntry.Distance = distance; hashedNodes.Add(secondNode, newEntry); bool added = sortedNodes.Add(ref newEntry.Handle, newEntry); Debug.Assert(added); } } } //hashedNodes.Remove(node); HashDictionary <Node, double> finalDistances = new HashDictionary <Node, double>(); foreach (NodeEntry entry in hashedNodes.Values) { finalDistances.Add(entry.Node, entry.Distance); } distances.Add(node, finalDistances); }
static void Main() { var people = new IntervalHeap<Person>(); people.Add(new Person("Nakov", 25)); people.Add(new Person("Petya", 24)); people.Add(new Person("Pesho", 25)); people.Add(new Person("Maria", 22)); people.Add(new Person("Ivan", -1)); Console.WriteLine("Min: {0}", people.FindMin()); Console.WriteLine("Max: {0}", people.FindMax()); while (people.Count > 0) { Console.WriteLine(people.DeleteMin()); } }
public void Bug20130208Case5b() { // Case 5b: only right.first, not max IPriorityQueue <double> q = new IntervalHeap <double>(); IPriorityQueueHandle <double> topRight = null; q.Add(20); q.Add(ref topRight, 30); q.Add(24); q.Add(28); q.Add(26); q[topRight] = 10; Assert.IsTrue(q.Check()); Assert.IsTrue(q.FindMax() == 28); }
public void Add(CompositeFactor cf) { if (hashes.Add(cf.GetLongHashCode())) { items.Add(cf); } }
//HELPERS protected override NetworkInterface getRoute(Node destination) { IntervalHeap <NodeEntry> sortedNodes = new IntervalHeap <NodeEntry>(); HashDictionary <Node, NodeEntry> hashedNodes = new HashDictionary <Node, NodeEntry>(); NodeEntry thisNode = new NodeEntry(); thisNode.Node = node; thisNode.Time = Timer.CurrentTime; bool added = sortedNodes.Add(ref thisNode.Handle, thisNode); NodeEntry temp; bool found = sortedNodes.Find(thisNode.Handle, out temp); Debug.Assert(found); Debug.Assert(added); hashedNodes.Add(node, thisNode); double currentTime = -1; while (sortedNodes.Count > 0) { NodeEntry current = sortedNodes.DeleteMin(); Debug.Assert(current.Time >= currentTime); currentTime = current.Time; if (current.Node == destination) { return(extractInterface(current, hashedNodes)); } nextMove(current, sortedNodes, hashedNodes); Debug.Assert(sortedNodes.Check()); } //route not found return(null); }
private static void addToFrontier(CytoscapeMap map, IntervalHeap <CytoscapeNode> frontier, CytoscapeNode node) { CytoscapeNode tempNode; foreach (CytoscapeConnection connection in node.connections) { int undirectedTargetID = connection.undirectedTarget(node); tempNode = map.getNode(undirectedTargetID); // Discard cyclic paths if (!node.hasVisitedNode(undirectedTargetID)) { // Keep track of the path taken if (node.path == null || !node.path.Any()) { node.path = new List <CytoscapeNode>(); node.path.Add(node); } // Make sure to be duplicating the path instead of pointing at node's path field tempNode.path = new List <CytoscapeNode>(node.path); tempNode.path.Add(tempNode); // f is the heuristic plus the distance traveled so far tempNode.distance = node.distance + connection.distance; tempNode.f = tempNode.heuristic + tempNode.distance; frontier.Add(tempNode); } } }
public static void DikstrasSearch(Node[] nodes, Node source) { var table = new HashDictionary <Node, Entry>(); foreach (var node in nodes) { table.Add(node, new Entry(false, float.MaxValue, null)); } var sourceEntry = table[source]; sourceEntry.cost = 0; table[source] = sourceEntry; var priorityQueue = new IntervalHeap <NodeAndCost>( new DelegateComparer <NodeAndCost>( (nodeAndCost1, nodeAndCost2) => nodeAndCost1.cost.CompareTo(nodeAndCost2.cost))) { new NodeAndCost(source, 0) }; while (!priorityQueue.IsEmpty) { var nodeAndCost = priorityQueue.DeleteMin(); var currentNode = nodeAndCost.node; if (table[currentNode].known) { continue; } var currentNodeEntry = table[currentNode]; currentNodeEntry.known = true; table[currentNode] = currentNodeEntry; foreach (var edge in currentNode.outEdges) { var toNode = edge.ToNode; var toNodeCost = table[currentNode].cost + edge.Cost; if (!(table[toNode].cost > toNodeCost)) { continue; } var toNodeEntry = table[toNode]; toNodeEntry.cost = toNodeCost; toNodeEntry.predecessor = currentNode; table[toNode] = toNodeEntry; priorityQueue.Add(new NodeAndCost(toNode, toNodeCost)); } } foreach (var node in nodes) { _NEXT_NODE_AND_COST_TABLE[new NodePair(source, node)] = ExtractNextNodeFromTable(table, source, node); } }
/// <summary> /// Dijkstra. Attempts to find the shortest path from start to end, only using pixels inside the "border pixel" collection that was discovered in FloodFill() <see cref="FloodFill"/> /// </summary> /// <param name="start"></param> /// <param name="end"></param> /// <returns></returns> private System.Collections.Generic.IList <Point> LeastCostPath(Point start, Point end) { var h = new IntervalHeap <Node>(new NodeCmpr()); var n = new Node { Back = null, Cost = 0, Point = start }; h.Add(n); _considered = new PixelTracker(_image.Width, _image.Height) { OutsideDefault = true }; while (!h.IsEmpty) { var node = h.DeleteMin(); if (node.Point.X == end.X && node.Point.Y == end.Y) { return(Backtrace(node)); } Follow(h, node, node.Point.X - 1, node.Point.Y - 1); Follow(h, node, node.Point.X - 1, node.Point.Y); Follow(h, node, node.Point.X - 1, node.Point.Y + 1); Follow(h, node, node.Point.X, node.Point.Y + 1); Follow(h, node, node.Point.X + 1, node.Point.Y + 1); Follow(h, node, node.Point.X + 1, node.Point.Y); Follow(h, node, node.Point.X + 1, node.Point.Y - 1); Follow(h, node, node.Point.X, node.Point.Y - 1); } return(new Point[] {}); }
/// <summary>Score items for a given user</summary> /// <param name="recommender">the recommender to use</param> /// <param name="user_id">the numerical ID of the user</param> /// <param name="candidate_items">a collection of numerical IDs of candidate items</param> /// <param name="n">number of items to return (optional)</param> /// <returns>a list of pairs, each pair consisting of the item ID and the predicted score</returns> public static System.Collections.Generic.IList<Pair<int, float>> ScoreItems(this IRecommender recommender, int user_id, System.Collections.Generic.IList<int> candidate_items, int n = -1) { if (n == -1) { var result = new Pair<int, float>[candidate_items.Count]; for (int i = 0; i < candidate_items.Count; i++) { int item_id = candidate_items[i]; result[i] = new Pair<int, float>(item_id, recommender.Predict(user_id, item_id)); } return result; } else { var comparer = new DelegateComparer<Pair<int, float>>( (a, b) => a.Second.CompareTo(b.Second) ); var heap = new IntervalHeap<Pair<int, float>>(n, comparer); float min_relevant_score = float.MinValue; foreach (int item_id in candidate_items) { float score = recommender.Predict(user_id, item_id); if (score > min_relevant_score) { heap.Add(new Pair<int, float>(item_id, score)); if (heap.Count > n) { heap.DeleteMin(); min_relevant_score = heap.FindMin().Second; } } } var result = new Pair<int, float>[heap.Count]; for (int i = 0; i < result.Length; i++) result[i] = heap.DeleteMax(); return result; } }
public List<Node> AStarSearch(Vector3 start, Vector3 end) { var frontier = new IntervalHeap<Node>(new NodeComparer()); var cameFrom = new Dictionary<string, Node>(); //var costSoFar = new Dictionary<string, int>(); var startNode = FindNode(start); var endNode = FindNode(end); frontier.Add(startNode); cameFrom.Add(startNode.ToString(), null); while (frontier.Any()) { var currentNode = frontier.FindMin(); frontier.DeleteMin(); if (currentNode == endNode) break; foreach (var neighbor in currentNode.Neighboors) { var neighborName = neighbor.ToString(); if (cameFrom.ContainsKey(neighborName)) continue; var newCost = Heuristic(endNode, neighbor); neighbor.Cost = newCost; frontier.Add(neighbor); cameFrom.Add(neighborName, currentNode); } } var current = endNode; var path = new List<Node> { current }; if (!cameFrom.ContainsKey(endNode.ToString())) return path; while (current != startNode) { if (!cameFrom.ContainsKey(current.ToString())) continue; current = cameFrom[current.ToString()]; path.Add(current); } return path; }
public override void Update(Pose goal) { bool[,] expanded = new bool[grid.NumColumns, grid.NumRows]; LinkedList<GridCell>[,] memoized = new LinkedList<GridCell>[grid.NumColumns, grid.NumRows]; GridCell startCell = grid.PointToCellPosition(goal.Position); IntervalHeap<GridCellValue> open = new IntervalHeap<GridCellValue>(); for (int c = 0; c < grid.NumColumns; c++) for (int r = 0; r < grid.NumRows; r++) { heuristic[c, r] = float.PositiveInfinity; expanded[c, r] = false; } heuristic[startCell.C, startCell.R] = 0f; open.Add(new GridCellValue(startCell, 0f)); while (!open.IsEmpty) { GridCell cell = open.DeleteMin().Position; expanded[cell.C, cell.R] = true; LinkedList<GridCell> neighbors = memoized[cell.C, cell.R]; if (neighbors == null) { neighbors = grid.Get8Neighbors(cell); memoized[cell.C, cell.R] = neighbors; } foreach (GridCell n in neighbors) { if (expanded[n.C, n.R]) continue; if (grid.OccupiedCells[n.C, n.R] > 0) continue; if (grid.GVD.GetObstacleDistance(n) <= Car.HALF_CAR_WIDTH) continue; float dist = cell.C == n.C || cell.R == n.R ? 1f : sqrt2; dist += heuristic[cell.C, cell.R]; if (dist < heuristic[n.C, n.R]) { heuristic[n.C, n.R] = dist; open.Add(new GridCellValue(n, dist)); } } } }
/// public virtual System.Collections.Generic.IList<Tuple<int, float>> Recommend( int user_id, int n = -1, System.Collections.Generic.ICollection<int> ignore_items = null, System.Collections.Generic.ICollection<int> candidate_items = null) { if (candidate_items == null) candidate_items = Enumerable.Range(0, MaxItemID - 1).ToList(); if (ignore_items == null) ignore_items = new int[0]; System.Collections.Generic.IList<Tuple<int, float>> ordered_items; if (n == -1) { var scored_items = new List<Tuple<int, float>>(); foreach (int item_id in candidate_items) if (!ignore_items.Contains(item_id)) { float score = Predict(user_id, item_id); if (score > float.MinValue) scored_items.Add(Tuple.Create(item_id, score)); } ordered_items = scored_items.OrderByDescending(x => x.Item2).ToArray(); } else { var comparer = new DelegateComparer<Tuple<int, float>>( (a, b) => a.Item2.CompareTo(b.Item2) ); var heap = new IntervalHeap<Tuple<int, float>>(n, comparer); float min_relevant_score = float.MinValue; foreach (int item_id in candidate_items) if (!ignore_items.Contains(item_id)) { float score = Predict(user_id, item_id); if (score > min_relevant_score) { heap.Add(Tuple.Create(item_id, score)); if (heap.Count > n) { heap.DeleteMin(); min_relevant_score = heap.FindMin().Item2; } } } ordered_items = new Tuple<int, float>[heap.Count]; for (int i = 0; i < ordered_items.Count; i++) ordered_items[i] = heap.DeleteMax(); } return ordered_items; }
public ArrayList RunTSP(City[] Cities) { Route = new ArrayList(); Stopwatch timer = new Stopwatch(); bAndBTime = new TimeSpan(); timer.Start(); Greedy greedyAlgorithm = new Greedy(Cities); ArrayList greedyRoute = greedyAlgorithm.RunGreedyTSP(); double[,] matrix = new double[Cities.Length, Cities.Length]; //Populate each array item with each respective edge cost for (int i = 0; i < Cities.Length; i++) {//O(n^2) for (int j = 0; j < Cities.Length; j++) { if (i == j) { matrix[i, j] = double.PositiveInfinity; } else { matrix[i, j] = Cities[i].costToGetTo(Cities[j]); } } } IntervalHeap<State> queue = new IntervalHeap<State>(); double bestSolutionSoFar = greedyAlgorithm.BestSolutionSoFar(); bssfUpdatesAmt = 0; prunedAmt = 0; State bssfState = null; totalStatesCreated = 0; //Start with some problem State curState = new State(matrix, 0, new Edge(-1, -1)); totalStatesCreated++; //Reduce Matrix //O(4n^2) curState.Reduce(); //Let the queue be the set of active subproblems //O(log(n)) queue.Add(curState); maxQueueCount = 0; bool timesUp = false; while (queue.Count > 0) {//O(2^n) or O(2^(8n^2 + 9n + 2log(n))) if (timer.Elapsed.Seconds >= 30) { timesUp = true; break; } //Choose a subproblem and remove it from the queue if (queue.Count > maxQueueCount) { maxQueueCount = queue.Count; } //O(log(n)) curState = queue.DeleteMin(); if (curState.Cost() < bestSolutionSoFar) {//O(8n^2 + 9n + 2log(n)) //For each lowest cost (each 0) double highestScore = double.NegativeInfinity; State[] includeExcludeStates = new State[2]; foreach (Edge edge in curState.LowestNums()) {//O(8n^2 + 9n) //Include Matrix State includeState = new State(curState, edge); //O(n) totalStatesCreated++; includeState.IncludeMatrix(edge.Row(), edge.Col()); //O(4n^2 + 7n) //Exclude Matrix State excludeState = new State(curState, edge); //O(n) totalStatesCreated++; excludeState.ExcludeMatrix(edge.Row(), edge.Col());//O(4n^2) //Find the score for that edge (Exclude cost - Include cost) double score = excludeState.Cost() - includeState.Cost(); if (score > highestScore) { includeExcludeStates[0] = includeState; includeExcludeStates[1] = excludeState; highestScore = score; } } foreach (State subproblemState in includeExcludeStates) {//O(2log(n)) //if each P (subproblem) chosen is a complete solution, update the bssf if (subproblemState.CompleteSolution() && subproblemState.Cost() < bestSolutionSoFar) { bestSolutionSoFar = subproblemState.Cost(); bssfState = subproblemState; bssfUpdatesAmt++; } //else if lowerBound < bestSolutionSoFar else if (!subproblemState.CompleteSolution() && subproblemState.Cost() < bestSolutionSoFar) { //O(log(n)) queue.Add(subproblemState); } else { prunedAmt++; } } } } if (!timesUp) prunedAmt += queue.Count; //Call this the best solution so far. bssf is the route that will be drawn by the Draw method. if (bssfState != null) { int index = bssfState.Exited(0); Route.Add(Cities[index]); index = bssfState.Exited(bssfState.Exited(0)); while (index != bssfState.Exited(0)) {//O(n) Route.Add(Cities[index]); index = bssfState.Exited(index); } } else { Route = greedyRoute; } timer.Stop(); bAndBTime = timer.Elapsed; this.count = bssfState.Cost(); // update the cost of the tour. timer.Reset(); return Route; }
public void Replace5b() { for (int size = 0; size < 130; size++) { IPriorityQueue<double> q = new IntervalHeap<double>(); IPriorityQueueHandle<double> handle1 = null; q.Add(ref handle1, -3.0); Assert.AreEqual(-3.0, q.FindMax()); for (int i = 1; i < size; i++) q.Add(-i - 3.0); Assert.AreEqual(-3.0, q.FindMax()); for (int max = -2; max <= 10; max++) { Assert.AreEqual(max - 1.0, q.Replace(handle1, max)); Assert.AreEqual(max, q.FindMax()); } Assert.AreEqual(10.0, q.DeleteMax()); for (int i = 1; i < size; i++) Assert.AreEqual(-i - 3.0, q.DeleteMax()); Assert.IsTrue(q.IsEmpty); } }
public void Replace5a() { for (int size = 0; size < 130; size++) { IPriorityQueue<double> q = new IntervalHeap<double>(); IPriorityQueueHandle<double> handle1 = null; q.Add(ref handle1, 3.0); Assert.AreEqual(3.0, q.FindMin()); for (int i = 1; i < size; i++) q.Add(i + 3.0); Assert.AreEqual(3.0, q.FindMin()); for (int min = 2; min >= -10; min--) { Assert.AreEqual(min + 1.0, q.Replace(handle1, min)); Assert.AreEqual(min, q.FindMin()); } Assert.AreEqual(-10.0, q.DeleteMin()); for (int i = 1; i < size; i++) Assert.AreEqual(i + 3.0, q.DeleteMin()); Assert.IsTrue(q.IsEmpty); } }
public void Bug20130208Case6b() { // Case 6b: both right.first and right.last, not max IPriorityQueue<double> q = new IntervalHeap<double>(); IPriorityQueueHandle<double> topRight = null; q.Add(20); q.Add(ref topRight, 30); q.Add(24); q.Add(28); q.Add(23); q.Add(26); q[topRight] = 10; Assert.IsTrue(q.Check()); Assert.IsTrue(q.FindMax() == 28); }
public void Bug20130208Case3() { // Case 3: only left.first IPriorityQueue<double> q = new IntervalHeap<double>(); IPriorityQueueHandle<double> topRight = null; q.Add(20); q.Add(ref topRight, 30); q.Add(25); q[topRight] = 10; Assert.IsTrue(q.Check()); Assert.IsTrue(q.FindMax() == 25); }
public void Bug20130208() { IPriorityQueue<double> q = new IntervalHeap<double>(); IPriorityQueueHandle<double> h0 = null, h2 = null, h4 = null, h7 = null, h5 = null; // Add(43, 0); q.Add(ref h0, 43); // Remove(); q.DeleteMin(); // XAddMaxReplace(9, 2); q.Add(ref h2, Double.MaxValue); q[h2] = 9; // XAddMaxReplace(32, 4); q.Add(ref h4, Double.MaxValue); q[h4] = 32; // XAddMaxReplace(44, 7); q.Add(ref h7, Double.MaxValue); q[h7] = 44; // Remove(); q.DeleteMin(); // XAddMaxReplace(0, 5); q.Add(ref h5, Double.MaxValue); q[h5] = 0; // Internally inconsistent data structure already now Assert.IsTrue(q.Check()); }
public List<Cell> FindPath(Point start, Point end) { m_open = new IntervalHeap<Cell>(m_capacity, new CellComparer()); m_closed = new List<Cell>(m_capacity); Cell temp; // Set parent to a starting point and set its g, h, f values Cell parent = this[start.X, start.Y]; parent.G = 0; parent.H = EstimateCost(start, end); parent.F = parent.G + parent.H; // Add parent to the open list, should be the only cell at this point m_open.Add(parent); while ( ! m_open.IsEmpty) { // Find the cell with the lowest f value // Pop it off the open and assign the value to parent parent = m_open.DeleteMin(); // If the best cell is the end, we're done if (parent.Coord == end) { m_closed.Add(parent); return ReconstructReversePath(m_closed); } // Walk through valid adjacent cells foreach (Point p in parent.Adjacent) { if (p.X >= 0 && p.Y >= 0 && p.X < m_width && p.Y < m_height) { int g = parent.G + GetCellCost(this[p]); if (g == parent.G) continue; // Check if m_open or m_closed contain a Cell with lower G value if (m_open.Find(n => n.Equals(this[p]), out temp) && temp.G <= g) continue; if (m_closed.Contains(this[p]) && m_closed.Find(n => n.Equals(this[p])).G <= g) continue; this[p].Parent = parent; this[p].G = g; this[p].H = EstimateCost(this[p].Coord, end); this[p].F = this[p].G + this[p].H; m_open.Add(this[p]); } } m_closed.Add(parent); } return null; }
/// <summary>Write item predictions (scores) to a TextWriter object</summary> /// <param name="recommender">the <see cref="IRecommender"/> to use for making the predictions</param> /// <param name="user_id">ID of the user to make recommendations for</param> /// <param name="candidate_items">list of candidate items</param> /// <param name="ignore_items">list of items for which no predictions should be made</param> /// <param name="num_predictions">the number of items to return per user, -1 if there should be no limit</param> /// <param name="writer">the <see cref="TextWriter"/> to write to</param> /// <param name="user_mapping">an <see cref="IEntityMapping"/> object for the user IDs</param> /// <param name="item_mapping">an <see cref="IEntityMapping"/> object for the item IDs</param> public static void WritePredictions( this IRecommender recommender, int user_id, System.Collections.Generic.IList<int> candidate_items, System.Collections.Generic.ICollection<int> ignore_items, int num_predictions, TextWriter writer, IEntityMapping user_mapping, IEntityMapping item_mapping) { System.Collections.Generic.IList<Pair<int, float>> ordered_items; if (user_mapping == null) user_mapping = new IdentityMapping(); if (item_mapping == null) item_mapping = new IdentityMapping(); if (num_predictions == -1) { var scored_items = new List<Pair<int, float>>(); foreach (int item_id in candidate_items) if (!ignore_items.Contains(item_id)) { float score = recommender.Predict(user_id, item_id); if (score > float.MinValue) scored_items.Add(new Pair<int, float>(item_id, score)); } ordered_items = scored_items.OrderByDescending(x => x.Second).ToArray(); } else { var comparer = new DelegateComparer<Pair<int, float>>( (a, b) => a.Second.CompareTo(b.Second) ); var heap = new IntervalHeap<Pair<int, float>>(num_predictions, comparer); float min_relevant_score = float.MinValue; foreach (int item_id in candidate_items) if (!ignore_items.Contains(item_id)) { float score = recommender.Predict(user_id, item_id); if (score > min_relevant_score) { heap.Add(new Pair<int, float>(item_id, score)); if (heap.Count > num_predictions) { heap.DeleteMin(); min_relevant_score = heap.FindMin().Second; } } } ordered_items = new Pair<int, float>[heap.Count]; for (int i = 0; i < ordered_items.Count; i++) ordered_items[i] = heap.DeleteMax(); } writer.Write("{0}\t[", user_mapping.ToOriginalID(user_id)); if (ordered_items.Count > 0) { writer.Write("{0}:{1}", item_mapping.ToOriginalID(ordered_items[0].First), ordered_items[0].Second.ToString(CultureInfo.InvariantCulture)); for (int i = 1; i < ordered_items.Count; i++) { int item_id = ordered_items[i].First; float score = ordered_items[i].Second; writer.Write(",{0}:{1}", item_mapping.ToOriginalID(item_id), score.ToString(CultureInfo.InvariantCulture)); } } writer.WriteLine("]"); }