#include "sliding_tile_lib.h"
+#include <cstdlib>
+#include <fstream>
#include <istream>
+#include <map>
+#include <memory>
+#include <ostream>
+#include <queue>
+#include <set>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
-signed char adjacent[BOARD_SIZE][5] = {
+#include <iostream>
+
+int Step::count = 0;
+signed char Step::adjacent[BOARD_SIZE][5] = {
1, 4, -1, -1, -1,
0, 2, 5, -1, -1,
1, 3, 6, -1, -1,
11, 14, -1, -1, -1,
};
+bool Board::is_valid() const {
+ bool seen[BOARD_SIZE];
+ for (int i = 0; i < BOARD_SIZE; i++) {
+ seen[i] = false;
+ }
+
+ for (int i = 0; i < BOARD_SIZE; i++) {
+ if (board[i] < 0 || board[i] >= BOARD_SIZE || seen[board[i]]) {
+ return false;
+ }
+ seen[board[i]] = true;
+ }
+
+ // Redundant because pigeon-hole-principle, but check anyway
+ for (int i = 0; i < BOARD_SIZE; i++) {
+ if (!seen[i]) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+bool Board::operator==(const Board& o) const {
+ for (int i = 0; i < BOARD_SIZE; i++) {
+ if (board[i] != o.board[i]) {
+ return false;
+ }
+ }
+ return true;
+}
+
+bool Board::operator!=(const Board& o) const {
+ return !operator==(o);
+}
+
+bool Board::operator<(const Board& o) const {
+ for (int i = 0; i < BOARD_SIZE; i++) {
+ if (board[i] < o.board[i]) {
+ return true;
+ } else if (board[i] > o.board[i]) {
+ return false;
+ }
+ }
+ return false;
+}
+
std::istream& operator>>(std::istream& is, Board& board) {
for (int i = 0; i < BOARD_SIZE; i++) {
if (!is.good()) {
is >> numeric;
board.board[i] = numeric;
}
+ if (!board.is_valid()) {
+ is.setstate(std::istream::failbit);
+ }
return is;
}
+
+std::ostream& operator<<(std::ostream& os, const Board& board) {
+ for (int i = 0; i < BOARD_SIZE; i++) {
+ if (i > 0) {
+ os << " ";
+ }
+ os << int(board.board[i]);
+ }
+ return os;
+}
+
+signed char Board::hole() const {
+ for (int i = 0; i < BOARD_SIZE; i++) {
+ if (board[i] == 0) {
+ return i;
+ }
+ }
+ throw std::runtime_error("Board with no hole");
+}
+
+InvertedBoard Board::invert() const {
+ InvertedBoard inv;
+ for (int i = 0; i < BOARD_SIZE; i++) {
+ inv.pos[board[i]] = i;
+ }
+ return inv;
+}
+
+int Board::distance(const Board& o) const {
+ return distance(o.invert());
+}
+
+int Board::distance(const InvertedBoard& invo) const {
+ int dist = 0;
+ for (int i = 0; i < BOARD_SIZE; i++) {
+ if (board[i] != 0) {
+ dist += std::abs(i % BOARD_DIM - invo.pos[board[i]] % BOARD_DIM) +
+ std::abs(i / BOARD_DIM - invo.pos[board[i]] / BOARD_DIM);
+ }
+ }
+ return dist;
+}
+
+Step::Step(Board board, std::shared_ptr<Step> prev) : board(board), prev(prev) {
+ count++;
+}
+
+Step::~Step() {
+ count--;
+}
+
+std::vector<std::shared_ptr<Step>> Step::successors(std::shared_ptr<Step> shared_this) const {
+ std::vector<std::shared_ptr<Step>> suc;
+ signed char hole_pos = board.hole();
+ for (int i = 0; adjacent[hole_pos][i] >= 0; i++) {
+ suc.emplace_back(std::make_shared<Step>(board, shared_this));
+ std::swap(suc.back()->board.board[hole_pos], suc.back()->board.board[adjacent[hole_pos][i]]);
+ }
+ return suc;
+}
+
+int Step::length() const {
+ if (prev.get() == nullptr) {
+ return 0;
+ }
+ return 1 + prev->length();
+}
+
+int Step::cost(const InvertedBoard& invgoal) const {
+ return length() + board.distance(invgoal) / 2;
+}
+
+std::ostream& operator<<(std::ostream& os, const Step& step) {
+ if (step.prev != nullptr) {
+ os << *step.prev;
+ signed char this_hole = step.board.hole();
+ signed char prev_hole = step.prev->board.hole();
+ os << int(step.board.board[prev_hole]) << " ";
+ switch (this_hole - prev_hole) {
+ case -1: os << "right"; break;
+ case 1: os << "left"; break;
+ case -BOARD_DIM: os << "down"; break;
+ case BOARD_DIM: os << "up"; break;
+ default: os << "somehow!"; break;
+ }
+ os << std::endl;
+ }
+ return os;
+}
+
+std::shared_ptr<Step> find_path(const std::string& start, const std::string& goal, unsigned max_frontier) {
+ std::istringstream iss_start{start}, iss_goal{goal};
+ Board board_start, board_goal;
+ iss_start >> board_start;
+ iss_goal >> board_goal;
+ if (iss_start.fail() || !iss_start.eof()) {
+ throw std::runtime_error("Could not parse the start board: " + start);
+ }
+ if (iss_goal.fail() || !iss_goal.eof()) {
+ throw std::runtime_error("Could not parse the goal board: " + goal);
+ }
+ return find_path(board_start, board_goal, max_frontier);
+}
+
+static void show_memory_stats() {
+ std::ifstream statm{"/proc/self/statm"};
+ if (statm.is_open()) {
+ std::string statm_data;
+ std::getline(statm, statm_data);
+ std::cerr << "Memory stats: " << statm_data << std::endl;
+ }
+}
+
+std::shared_ptr<Step> find_path(const Board& start, const Board& goal, unsigned max_frontier) {
+ InvertedBoard invgoal = goal.invert();
+ std::multimap<int, std::shared_ptr<Step>> todo;
+ std::set<Board> seen;
+
+ seen.insert(start);
+ auto start_step = std::make_shared<Step>(start, nullptr);
+ todo.emplace(start_step->cost(invgoal), start_step);
+ while (!todo.empty()) {
+ auto cur = todo.begin()->second;
+ todo.erase(todo.begin());
+ if (cur->board == goal) {
+ show_memory_stats();
+ return cur;
+ }
+ std::vector<std::shared_ptr<Step>> successors = cur->successors(cur);
+ for (const std::shared_ptr<Step>& s : successors) {
+ if (seen.find(s->board) == seen.end()) {
+ seen.insert(s->board);
+ todo.emplace(s->cost(invgoal), s);
+ if (seen.size() % 10000 == 0) {
+ std::cerr << "Examined " << seen.size() << " boards. Tracking "
+ << Step::count << " steps. " << todo.size()
+ << " waiting. Considering paths of length "
+ << cur->cost(invgoal) << std::endl;
+ }
+ }
+ }
+ while (todo.size() > max_frontier) {
+ todo.erase(--todo.end());
+ }
+ }
+ throw std::runtime_error("No path from start to goal");
+}
projects / slidingtile / blobdiff