Tweak the default max_frontier

[slidingtile] / sliding_tile_lib.cc

diff --git a/sliding_tile_lib.cc b/sliding_tile_lib.cc
index 9f6bfc9ff62dffa6b776a74350ed1ad110384d65..83d6297b42a57505164833b809a411d2050c13b7 100644 (file)
--- a/sliding_tile_lib.cc
+++ b/sliding_tile_lib.cc
@@ -1,17 +1,21 @@
 #include "sliding_tile_lib.h"
 
 #include <cstdlib>
 #include "sliding_tile_lib.h"
 
 #include <cstdlib>

+#include <fstream>

 #include <istream>
 #include <istream>

+#include <map>

 #include <memory>
 #include <ostream>
 #include <queue>
 #include <set>
 #include <sstream>
 #include <stdexcept>
 #include <memory>
 #include <ostream>
 #include <queue>
 #include <set>
 #include <sstream>
 #include <stdexcept>

+#include <string>

 #include <vector>
 
 #include <iostream>
 
 #include <vector>
 
 #include <iostream>
 

+int Step::count = 0;

 signed char Step::adjacent[BOARD_SIZE][5] = {
   1,   4,   -1,  -1,  -1,
   0,   2,   5,   -1,  -1,
 signed char Step::adjacent[BOARD_SIZE][5] = {
   1,   4,   -1,  -1,  -1,
   0,   2,   5,   -1,  -1,


@@ -132,13 +136,21 @@ int Board::distance(const Board& o) const {
 int Board::distance(const InvertedBoard& invo) const {
   int dist = 0;
   for (int i = 0; i < BOARD_SIZE; i++) {
 int Board::distance(const InvertedBoard& invo) const {
   int dist = 0;
   for (int i = 0; i < BOARD_SIZE; i++) {

-    dist += std::abs(i % BOARD_DIM - invo.pos[board[i]] % BOARD_DIM) +
-            std::abs(i / BOARD_DIM - invo.pos[board[i]] / BOARD_DIM);
+    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;
 }
 
   }
   return dist;
 }
 

-Step::Step(Board board, std::shared_ptr<Step> prev) : board(board), prev(prev) {}
+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;
 
 std::vector<std::shared_ptr<Step>> Step::successors(std::shared_ptr<Step> shared_this) const {
   std::vector<std::shared_ptr<Step>> suc;


@@ -179,7 +191,7 @@ std::ostream& operator<<(std::ostream& os, const Step& step) {
   return os;
 }
 
   return os;
 }
 

-std::shared_ptr<Step> find_path(const std::string& start, const std::string& goal) {
+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;
   std::istringstream iss_start{start}, iss_goal{goal};
   Board board_start, board_goal;
   iss_start >> board_start;


@@ -190,38 +202,49 @@ std::shared_ptr<Step> find_path(const std::string& start, const std::string& goa
   if (iss_goal.fail() || !iss_goal.eof()) {
     throw std::runtime_error("Could not parse the goal board: " + goal);
   }
   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);
+  return find_path(board_start, board_goal, max_frontier);

 }
 
 }
 

-std::shared_ptr<Step> find_path(const Board& start, const Board& goal) {
+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();
   InvertedBoard invgoal = goal.invert();

-  auto heap_greater = [invgoal](const std::shared_ptr<Step>& a, const std::shared_ptr<Step>& b) {
-    return a->cost(invgoal) > b->cost(invgoal);
-  };
-  std::priority_queue<std::shared_ptr<Step>,
-                      std::vector<std::shared_ptr<Step>>,
-                      decltype(heap_greater)> todo(heap_greater);
+  std::multimap<int, std::shared_ptr<Step>> todo;

   std::set<Board> seen;
 
   std::set<Board> seen;
 

-  seen.emplace(start);
-  todo.push(std::make_shared<Step>(start, nullptr));
+  seen.insert(start);
+  auto start_step = std::make_shared<Step>(start, nullptr);
+  todo.emplace(start_step->cost(invgoal), start_step);

   while (!todo.empty()) {
   while (!todo.empty()) {

-    if (todo.top()->board == goal) {
-      return todo.top();
+    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 = todo.top()->successors(todo.top());
+    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()) {
     for (const std::shared_ptr<Step>& s : successors) {
       if (seen.find(s->board) == seen.end()) {

-        seen.emplace(s->board);
-        todo.push(s);
+        seen.insert(s->board);
+        todo.emplace(s->cost(invgoal), s);

         if (seen.size() % 10000 == 0) {
         if (seen.size() % 10000 == 0) {

-          std::cerr << "Examined " << seen.size() << " boards.  " << todo.size()
+          std::cerr << "Examined " << seen.size() << " boards.  Tracking "
+                    << Step::count << " steps.  " << todo.size()

                     << " waiting.  Considering paths of length "
                     << " waiting.  Considering paths of length "

-                    << todo.top()->cost(invgoal) << std::endl;
+                    << cur->cost(invgoal) << std::endl;

         }
       }
     }
         }
       }
     }

-    todo.pop();
+    while (todo.size() > max_frontier) {
+      todo.erase(--todo.end());
+    }

   }
   throw std::runtime_error("No path from start to goal");
 }
   }
   throw std::runtime_error("No path from start to goal");
 }