public List <T> Run(T start, Satisfies satisfies, GetNeighbours getNeighbours, int watchdog = 50) { //Creamos un linkeo de hijos-padres Dictionary <T, T> parents = new Dictionary <T, T>(); //Creamos una cola (Una fila, en donde el primero que ingresa es el primero en salir) Stack <T> pending = new Stack <T>(); //Creamos coleccion para tener todos los nodos que ya fueron visitados HashSet <T> visited = new HashSet <T>(); //Agregamos el nodo start a pendientes pending.Push(start); while (pending.Count != 0) { watchdog--; if (watchdog <= 0) { return(new List <T>()); } //Sacame el primero de pendientes T current = pending.Pop(); //Compurevo si ese nodo me satisface if (satisfies(current)) { List <T> path = new List <T>(); path.Add(current); //Mientras que parents contenga la key del ultimo item del path while (parents.ContainsKey(path[path.Count - 1])) { //se va a agregar al path el padre del ultimo item del path var lastNode = path[path.Count - 1]; path.Add(parents[lastNode]); } //Damos vuelta la coleccion path.Reverse(); //La retornamos return(path); } //Agregamos ese nodo a visitados visited.Add(current); //Obtenemos sus vecinos List <T> neighbours = getNeighbours(current); for (int i = 0; i < neighbours.Count; i++) { T item = neighbours[i]; if (visited.Contains(item) || pending.Contains(item)) { continue; } else { //Agregamos sus vecinos en pendientes pending.Push(item); //Realizamos el linkeo de sus vecinos con el nodo parents[item] = current; } } } return(new List <T>()); }
public RequiredAndSatisfied(Requires requirement, Satisfies satisfier, double quantity) { this.requirement = requirement; this.satisfier = satisfier; this.quantity = quantity; requirement.RequiredAndSatisfieds.Add(this); satisfier.RequiredAndSatisfieds.Add(this); }
public List <T> Run(T start, Satisfies satisfies, GetNeighbours getNeighbours, GetCost getcost, Heuristic heuristic, InSight inSight, int watchDong = 500) { Dictionary <T, float> cost = new Dictionary <T, float>(); Dictionary <T, T> parents = new Dictionary <T, T>(); PriorityQueue <T> pending = new PriorityQueue <T>(); HashSet <T> visited = new HashSet <T>(); pending.Enqueue(start, 0); cost.Add(start, 0); while (!pending.IsEmpty) { T current = pending.Dequeue(); watchDong--; if (watchDong <= 0) { return(new List <T>()); } if (satisfies(current)) { return(ConstructPath(current, parents)); } visited.Add(current); List <T> neighbours = getNeighbours(current); for (int i = 0; i < neighbours.Count; i++) { T node = neighbours[i]; if (visited.Contains(node)) { continue; } T currParent; if (parents.ContainsKey(current) && inSight(parents[current], node)) { currParent = parents[current]; } else { currParent = current; } float nodeCost = getcost(currParent, node); float totalCost = cost[currParent] + nodeCost; if (cost.ContainsKey(node) && cost[node] < totalCost) { continue; } cost[node] = totalCost; parents[node] = currParent; pending.Enqueue(node, totalCost + heuristic(node)); } } return(new List <T>()); }
public List <T> Run(T start, Satisfies satisfies, GetNeighbours getNeighbours, GetCost getCost, Heuristic heuristic, int watchdog = 100) { Dictionary <T, T> parents = new Dictionary <T, T>(); PriorityQueue <T> pending = new PriorityQueue <T>(); Dictionary <T, float> cost = new Dictionary <T, float>(); HashSet <T> visited = new HashSet <T>(); pending.Enqueue(start, 0); cost.Add(start, 0); while (!pending.IsEmpty) { watchdog--; if (watchdog <= 0) { return(new List <T>()); } T current = pending.Dequeue(); if (satisfies(current)) { return(ConstructPath(current, parents)); } visited.Add(current); List <T> neighbours = getNeighbours(current); for (int i = 0; i < neighbours.Count; i++) { var item = neighbours[i]; if (visited.Contains(item)) { continue; } float totalCost = cost[current] + getCost(current, item); if (cost.ContainsKey(item) && cost[item] < totalCost) { continue; } cost[item] = totalCost; parents[item] = current; pending.Enqueue(item, totalCost + heuristic(item)); } } return(new List <T>()); }