public void update(List<Point> ghostPositions) { for (int i = 0; i < ghosts.size(); ++i) { Ghost ghost = ghosts.get(i); Cell currentCell = getCell(ghost.getPosition()); Cell newCell = getCell(ghostPositions.get(i)); if (!currentCell.equals(newCell)) { grid.get(currentCell.row).get(currentCell.column).remove(ghost); grid.get(newCell.row).get(newCell.column).add(ghost); } } }
public int otherStringsEndInTheSameColumn(Cell cell) { if (!isStringsEnd(cell)) return 0; int result = 0; int height = getHeight(); for (int y = 0; y < height; y++) { Cell cCell = new Cell(cell.x, y); if (!cCell.equals(cell) && isStringsEnd(cCell)) { result++; } } return result; }
public static ArrayList<Cell> findPath(Cell start, Cell goal, Map<String, Cell> gridCells) { Set<Cell> closedSet = new HashSet<>(); Set<Cell> openSet = new HashSet<>(); openSet.add(start); start.g = 0; start.h = heuristicCostEstimate(start, goal); start.f = start.g + start.h; while (!openSet.isEmpty()) { double min = Integer.MAX_VALUE; Cell x = null; for (Cell cell : openSet) if (cell.f < min) { x = cell; min = cell.f; } if (goal.equals(x)) return reconstructPath(start, goal); openSet.remove(x); closedSet.add(x); for (Cell y : neighborNodes(x, gridCells)) { if (closedSet.contains(y)) continue; boolean tentativeIsBetter; // <tentative> double tentativeG = x.g + 2; if (x.cameFrom != null) { if (x.cameFrom.cameFrom != null && Math.abs(x.cameFrom.cameFrom.x - y.x) + Math.abs(x.cameFrom.cameFrom.y - y.y) == 1) { tentativeG += 2; } if (x.cameFrom.y == x.y && y.y != x.y || x.cameFrom.x == x.x && y.x != x.x) { tentativeG += (2 * Math.sqrt(2) - 4); } } if (y.isPenult) tentativeG += 10; // </tentative> if (!openSet.contains(y)) { openSet.add(y); tentativeIsBetter = true; } else { tentativeIsBetter = tentativeG < y.g; } if (tentativeIsBetter) { y.cameFrom = x; y.g = tentativeG; y.h = heuristicCostEstimate(y, goal); y.f = y.g + y.h; } } } return new ArrayList<>(); }
/** * Returns the ghosts in the cell of the line segment ab and the ghosts of this cell's * 8-neighborhood. * * @param a Start point of the line segment. * @param b End point of the line segment. * @return List of ghosts. */ public Set<Ghost> getGhosts(Point a, Point b) { Cell cA = getCell(a); Cell cB = getCell(b); Set<Ghost> ghosts = new HashSet<Ghost>(); ghosts.addAll(grid.get(cA.row).get(cA.column)); ghosts.addAll(get8Neighborhood(cA)); if (!cB.equals(cA)) { ghosts.addAll(grid.get(cB.row).get(cB.column)); ghosts.addAll(get8Neighborhood(cB)); } return ghosts; }
/** @return the largest connected component of the graph. */ public ArrayList<Cell> getLargestConnectedComponent() { ArrayList<ArrayList<Cell>> components = new ArrayList<>(); boolean visited[][] = new boolean[rowCount][colCount]; for (int row = 0; row < rowCount; ++row) for (int col = 0; col < colCount; ++col) visited[row][col] = false; Queue<Cell> q; Cell t = null, u = null; for (Cell c : g.vertexSet()) { if (!visited[c.getRow()][c.getCol()]) { q = new LinkedList<Cell>(); ArrayList<Cell> component = new ArrayList<>(); visited[c.getRow()][c.getCol()] = true; // Find all connected nodes q.add(c); component.add(c); while (!q.isEmpty()) { t = q.remove(); for (WeightedEdge e : g.edgesOf(t)) { u = t.equals(g.getEdgeSource(e)) ? g.getEdgeTarget(e) : g.getEdgeSource(e); if (!visited[u.getRow()][u.getCol()]) { visited[u.getRow()][u.getCol()] = true; q.add(u); component.add(u); } } } components.add(component); } } int largestSize = 0, largestIndex = 0; for (int i = 0; i < components.size(); ++i) { if (components.get(i).size() > largestSize) { largestSize = components.get(i).size(); largestIndex = i; } } filterGraph(components.get(largestIndex)); return components.get(largestIndex); }
/** * Resets the current solution based on the given Constraints. Cells which are not constrained can * take all possible values * * @param constraints the Constraints object used to initialise this solution */ public void reset(Constraints constraints) { Set<Cell> blankCells = new HashSet<Cell>(); for (int i = 0; i < dimSq; i++) { for (int j = 0; j < dimSq; j++) { Cell cell = new Cell(i, j); Set<Integer> values = new HashSet<Integer>(); for (int z = 1; z <= dimSq; z++) { Integer value = new Integer(z); values.add(value); } cell.setValues(values); blankCells.add(cell); } } Set<Cell> constrainedCells = constraints.getCells(); for (Cell constrainedCell : constrainedCells) { for (Cell blankCell : blankCells) { if (blankCell.equals(constrainedCell)) { cells.remove(blankCell); cells.add(constrainedCell); } } } }
boolean containsCell(Cell in) { for (Cell c : this) { if (c.equals(in)) return true; } return false; }