public override double Search(bool quiet = false)
{
TSPSolver solver = new GreedyImprovedSolver();
var tspinp = new VisitAllState((IState)this.sasProblem.GetInitialState(), dom).toTSP();
var solution = solver.solveStartPoint(tspinp.input, tspinp.position);
plan = dom.transformToPlan((TSPSolutionPath)solution);
if (drawTSPPlan)
{
vis.draw(plan);
}
VisitAllGoalDistanceCalculator c = new VisitAllGoalDistanceCalculator();
var state = new VisitAllState((IState)this.sasProblem.GetInitialState(), dom);
double dist = c.computeDistance(state);
if (dist < previousBest)
{
previousBest = dist;
withoutImprovement = 0;
}
else
{
withoutImprovement++;
}
if (drawNonimproving && withoutImprovement >= 8)
{
vis.draw(state);
}
return(plan.Count() - 1);
return(c.computeDistance(state));
}
public Tile(VisitAllNode node, VisitAllState state)
{
this.node = node;
/*
* if (node.ID == 119)
* {
*
* }
*/
this.isLeaf = false;
this.isBlack = (node.gridCoordX + node.gridCoordY) % 2 == 0;
this.isVisited = state.visited[this.ID];
int nonVisitedNeighours = 0;
foreach (var item in this.node.successors)
{
if (!state.visited[item.ID])
{
nonVisitedNeighours++;
}
}
if (!this.isVisited && nonVisitedNeighours == 1)
{
this.isLeaf = true;
}
if (this.isVisited && nonVisitedNeighours > 0)
{
this.visitedConectedToNonVisited = nonVisitedNeighours;
}
if (!isVisited)
{
this.governor = new ComponentGovernor();
}
}
private int distanceToNearestNonVisited(VisitAllState s)
{
HashSet <int> processedItems = new HashSet <int>();
Queue <int> queue = new Queue <int>();
processedItems.Add(s.position);
queue.Enqueue(s.position);
while (queue.Count > 0)
{
var item = queue.Dequeue();
if (!s.visited[item])
{
return(manhatonDistance(allTilesbyIDs[item], allTilesbyIDs[s.position]));
}
Tile t = allTilesbyIDs[item];
foreach (var succ in t.node.successors)
{
if (!processedItems.Contains(succ.ID))
{
processedItems.Add(succ.ID);
queue.Enqueue(succ.ID);
}
}
}
return(int.MaxValue);
}
public override List <string> getPDDLPlan()
{
List <string> result = new List <string>();
int previousPos = new VisitAllState(plan[0], dom).position;
for (int i = 1; i < plan.Count; i++)
{
var currentState = new VisitAllState(plan[i], dom);
var pos = currentState.position;
result.Add("(move " + dom.nodes[previousPos].originalName + " " + dom.nodes[pos].originalName + ")");
previousPos = pos;
}
return(result);
}
public void draw(VisitAllState state = null)
{
g.Clear(backColor);
for (int i = 0; i < maxGridWidth; i++)
{
for (int j = 0; j < maxGridHeigth; j++)
{
var node = domain.nodes.Where(n => n.gridCoordX == i && n.gridCoordY == j).Single();
g.DrawRectangle(gridPen, i * tileSize, j * tileSize, tileSize, tileSize);
if (state?.visited[node.ID] == true)
{
g.FillRectangle(visitedBrush, i * tileSize + 1, j * tileSize + 1, tileSize - 2, tileSize - 2);
}
if (state?.position == node.ID)
{
g.FillEllipse(Brushes.BlueViolet, i * tileSize + tileSize * targetCrossMarginPercent / 100, j * tileSize + tileSize * targetCrossMarginPercent / 100,
tileSize - 2 * tileSize * targetCrossMarginPercent / 100, tileSize - 2 * tileSize * targetCrossMarginPercent / 100);
}
g.DrawString(node.ID.ToString(), IDStringFont, idStringBrush, i * tileSize + 1, j * tileSize + 1);
}
}
/*
* for (int i = 0; i < domain.nodes.Count(); i++)
* for (int j = i + 1; j < domain.nodes.Count(); j++)
* {
* if (domain.connected[i, j])
* {
* g.DrawLine(connectedPen, domain.nodes[i].gridCoordX * tileSize + tileSize / 2, domain.nodes[i].gridCoordY * tileSize + tileSize / 2,
* domain.nodes[j].gridCoordX * tileSize + tileSize / 2, domain.nodes[j].gridCoordY * tileSize + tileSize / 2);
* }
* }
*/
screen.Refresh();
if (!form.Visible)
{
form.ShowDialog();
}
}
public double computeDistance(VisitAllState s)
{
//return computeDistnaceTSP(s);
init();
foreach (var item in s.domain.nodes)
{
Tile t = new Tile(item, s);
if (!t.isVisited && t.isBlack)
{
blackTiles++;
}
if (!t.isVisited && !t.isBlack)
{
whiteTiles++;
}
if (t.isLeaf)
{
if (t.isBlack)
{
blackLeaves++;
}
else
{
whiteLeaves++;
}
}
if (t.isVisited)
{
visited++;
visitedTouchingNonVisited += t.visitedConectedToNonVisited;
}
allTilesbyIDs.Add(item.ID, t);
}
foreach (var item in allTilesbyIDs.Values)
{
item.computeGovernance(allTilesbyIDs);
}
int nonVisitedTiles = allTilesbyIDs.Count() - visited;
if (nonVisitedTiles == 0)
{
return(0);
}
int penalty = 0;
if (blackTiles > whiteTiles + 1)
{
penalty += blackTiles - (whiteTiles + 1);
penalty += whiteLeaves;
if (blackLeaves > blackTiles - (whiteTiles + 1))
{
penalty += blackLeaves - (blackTiles - (whiteTiles + 1));
}
}
else
{
if (whiteTiles > blackTiles + 1)
{
penalty += whiteTiles - (blackTiles + 1);
penalty += blackLeaves;
if (whiteLeaves > whiteTiles - (blackTiles + 1))
{
penalty += whiteLeaves - (whiteTiles - (blackTiles + 1));
}
}
else
{
penalty += Math.Max(0, whiteLeaves + blackLeaves - 2);
}
}
penalty += ComponentGovernor.highestGovernors.Count() - 1; //number of components
penalty += distanceToNearestNonVisited(s) - 1;
double result = 20 * nonVisitedTiles + penalty + (double)visitedTouchingNonVisited / (allTilesbyIDs.Count() * 4);
return(result); // + computeDistnaceTSP(s) / 10;
}
//TSPSolver solver = new GreedySolver();
private double computeDistnaceTSP(VisitAllState s)
{
var tspinp = s.toTSP();
return(solver.solveStartPoint(tspinp.input, tspinp.position).totalDistance);
}
