public override bool Solve()
{
CostTreeNodeSolverOldMatching nodeSolver = new CostTreeNodeSolverOldMatching(problem, runner); // TODO: This begs a factory.
SinglePlan[] ans = null;
int sumSubGroupA;
int sumSubGroupB;
//TODO if no solution found the algorithm will never stop
while (runner.ElapsedMilliseconds() < Constants.MAX_TIME)
{
costTreeNode = openList.Peek();
sumSubGroupA = costTreeNode.Sum(0, this.sizeOfA);
sumSubGroupB = costTreeNode.Sum(this.sizeOfA, costTreeNode.costs.Length);
if (maxCost != -1)
{
//if we are above the given solution return no solution found
if (sumSubGroupA + sumSubGroupB > maxCost)
{
return(this.minCAViolations != int.MaxValue);
}
//if we are below the given solution no need to do goal test just expand node
if (sumSubGroupA + sumSubGroupB < maxCost)
{
costTreeNode.Expand(openList, closedList);
openList.Dequeue();
continue;
}
}
// Reuse optimal solutions to previously solved subproblems
// Eli: Does this actually happen?
if (sumSubGroupA >= costA && sumSubGroupB >= costB)
{
nodeSolver.Setup(costTreeNode, syncSize);
expandedHL++;
ans = nodeSolver.Solve(ID_CAT, CBS_CAT);
generatedLL += nodeSolver.generated;
expandedLL += nodeSolver.expanded;
if (ans != null)
{
if (ans[0] != null)
{
if (Constants.EXHAUSTIVE_ICTS == false)
{
this.totalCost = nodeSolver.totalCost;
this.solutionDepth = nodeSolver.totalCost - this.initialEstimate;
this.solution = ans;
CostTreeSearchSolver.passed--;
return(true);
}
if (nodeSolver.caViolations < this.minCAViolations)
{
this.totalCost = nodeSolver.totalCost;
this.solutionDepth = nodeSolver.totalCost - this.initialEstimate;
this.solution = ans;
CostTreeSearchSolver.passed--;
this.minCAViolations = nodeSolver.caViolations;
this.maxCost = totalCost;
if (nodeSolver.caViolations == 0)
{
return(true);
}
}
}
}
}
costTreeNode.Expand(openList, closedList);
generatedHL += costTreeNode.costs.Length;
openList.Dequeue();
}
this.totalCost = Constants.TIMEOUT_COST;
this.solutionDepth = nodeSolver.totalCost - this.initialEstimate; // A lower bound
Console.WriteLine("Out of time");
return(false);
}
public override bool Solve()
{
//long time=0;
CostTreeNodeSolverOldMatching next = new CostTreeNodeSolverOldMatching(problem, runner);
LinkedList <Move>[] ans = null;
int sumSubGroupA;
int sumSubGroupB;
//TODO if no solution found the algorithm will never stop
while (runner.ElapsedMilliseconds() < Constants.MAX_TIME)
{
costTreeNode = openList.First.Value;
sumSubGroupA = costTreeNode.sum(0, sizeOfA);
sumSubGroupB = costTreeNode.sum(sizeOfA, costTreeNode.costs.Length);
if (maxCost != -1)
{
//if we are above the given solution return no solution found
if (sumSubGroupA + sumSubGroupB > maxCost)
{
return(this.minCAViolations != int.MaxValue);
}
//if we are below the given solution no need to do goal test just expand node
if (sumSubGroupA + sumSubGroupB < maxCost)
{
costTreeNode.expandNode(openList, closedList);
openList.RemoveFirst();
continue;
}
}
// Reuse optimal solutions to previously solved subproblems
if (sumSubGroupA >= costA && sumSubGroupB >= costB)
{
next.setup(costTreeNode, syncSize);
expandedHL++;
ans = next.Solve(ID_CAT, CBS_CAT);
generatedLL += next.generated;
expandedLL += next.expanded;
if (ans != null)
{
if (ans[0] != null)
{
if (Constants.exhaustiveIcts == false)
{
totalCost = next.costs.Sum();
solution = ans;
passed--;
return(true);
}
if (next.caViolations < this.minCAViolations)
{
totalCost = next.costs.Sum();
solution = ans;
passed--;
this.minCAViolations = next.caViolations;
maxCost = totalCost;
if (next.caViolations == 0)
{
return(true);
}
}
}
}
}
costTreeNode.expandNode(openList, closedList);
generatedHL += costTreeNode.costs.Length;
openList.RemoveFirst();
}
totalCost = Constants.TIMEOUT_COST;
Console.WriteLine("Out of time");
return(false);
}
