From 20ba0067b876bc49c3fe161e22161129c81c8277 Mon Sep 17 00:00:00 2001 From: Justin Heyes-Jones Date: Sun, 25 Jul 2021 14:58:39 -0700 Subject: [PATCH] wip --- cpp/15puzzle | Bin 0 -> 97424 bytes cpp/15puzzle.cpp | 742 +++++++++++++++++++++++++++++++++++++++++++++++ cpp/makefile | 7 +- cpp/stlastar.h | 2 +- 4 files changed, 748 insertions(+), 3 deletions(-) create mode 100755 cpp/15puzzle create mode 100755 cpp/15puzzle.cpp diff --git a/cpp/15puzzle b/cpp/15puzzle new file mode 100755 index 0000000000000000000000000000000000000000..3a1948b1be6a573ab5322c9565483857b3a2b69b GIT binary patch literal 97424 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

sPq`H?CK3jp51%%^A4<3-2@WoQ3O8c>go5 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 literal 0 HcmV?d00001 diff --git a/cpp/15puzzle.cpp b/cpp/15puzzle.cpp new file mode 100755 index 0000000..77ac495 --- /dev/null +++ b/cpp/15puzzle.cpp @@ -0,0 +1,742 @@ +//////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// STL A* Search implementation +// (C)2001 Justin Heyes-Jones +// +// This uses my A* code to solve the 8-puzzle + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include +#include +#include +#include + +using namespace std; + +// Configuration + +#define NUM_TIMES_TO_RUN_SEARCH 1 +#define DISPLAY_SOLUTION_FORWARDS 1 +#define DISPLAY_SOLUTION_BACKWARDS 0 +#define DISPLAY_SOLUTION_INFO 1 +#define DEBUG_LISTS 1 + +// AStar search class +#include "stlastar.h" // See header for copyright and usage information + +// Global data + +#define BOARD_WIDTH (4) +#define BOARD_HEIGHT (4) + +#define GM_TILE (-1) +#define GM_SPACE (0) +#define GM_OFF_BOARD (1) + +// Definitions + +// To use the search class you must define the following calls... + +// Data +// Your own state space information +// Functions +// (Optional) Constructor. +// Nodes are created by the user, so whether you use a +// constructor with parameters as below, or just set the object up after the +// constructor, is up to you. +// +// (Optional) Destructor. +// The destructor will be called if you create one. You +// can rely on the default constructor unless you dynamically allocate something in +// your data +// +// float GoalDistanceEstimate( PuzzleState &nodeGoal ); +// Return the estimated cost to goal from this node (pass reference to goal node) +// +// bool IsGoal( PuzzleState &nodeGoal ); +// Return true if this node is the goal. +// +// bool GetSuccessors( AStarSearch *astarsearch ); +// For each successor to this state call the AStarSearch's AddSuccessor call to +// add each one to the current search - return false if you are out of memory and the search +// will fail +// +// float GetCost( PuzzleState *successor ); +// Return the cost moving from this state to the state of successor +// +// bool IsSameState( PuzzleState &rhs ); +// Return true if the provided state is the same as this state + +// Here the example is the 8-puzzle state ... +class PuzzleState +{ + +public: + + // defs + + typedef enum + { + TL_SPACE, + TL_1, + TL_2, + TL_3, + + TL_4, + TL_5, + TL_6, + TL_7, + + TL_8, + TL_9, + TL_10, + TL_11, + + TL_12, + TL_13, + TL_14, + TL_15, + } TILE; + + // data + + static TILE g_goal[ BOARD_WIDTH*BOARD_HEIGHT]; + static TILE g_start[ BOARD_WIDTH*BOARD_HEIGHT]; + + // the tile data for the 8-puzzle + TILE tiles[ BOARD_WIDTH*BOARD_HEIGHT ]; + + // member functions + + PuzzleState() { + memcpy( tiles, g_goal, sizeof( TILE ) * BOARD_WIDTH * BOARD_HEIGHT ); + } + + PuzzleState( TILE *param_tiles ) + { + memcpy( tiles, param_tiles, sizeof( TILE ) * BOARD_WIDTH * BOARD_HEIGHT ); + } + + float GoalDistanceEstimate( PuzzleState &nodeGoal ); + bool IsGoal( PuzzleState &nodeGoal ); + bool GetSuccessors( AStarSearch *astarsearch, PuzzleState *parent_node ); + float GetCost( PuzzleState &successor ); + bool IsSameState( PuzzleState &rhs ); + + void PrintNodeInfo(); + +private: + // User stuff - Just add what you need to help you write the above functions... + + void GetSpacePosition( PuzzleState *pn, int *rx, int *ry ); + bool LegalMove( TILE *StartTiles, TILE *TargetTiles, int spx, int spy, int tx, int ty ); + int GetMap( int x, int y, TILE *tiles ); +}; + +// Goal state +PuzzleState::TILE PuzzleState::g_goal[] = +{ + + TL_SPACE, + TL_1, + TL_2, + TL_3, + + TL_4, + TL_5, + TL_6, + TL_7, + + TL_8, + TL_9, + TL_10, + TL_11, + + TL_12, + TL_13, + TL_14, + TL_15, +}; + +PuzzleState::TILE PuzzleState::g_start[] = +{ + +#if 0 + TL_10, + TL_2, + TL_7, + TL_1, + TL_14, + TL_SPACE, + TL_8, + TL_4, + TL_13, + TL_5, + TL_15, + TL_12, + TL_9, + TL_11, + TL_3, + TL_6, + +#elif 1 // ass + TL_4, + TL_1, + TL_2, + TL_3, + TL_SPACE, + TL_5, + TL_6, + TL_7, + TL_8, + TL_9, + TL_10, + TL_11, + TL_12, + TL_13, + TL_14, + TL_15, +#elif 0 // works + TL_1, + TL_SPACE, + TL_2, + TL_3, + TL_4, + TL_5, + TL_6, + TL_7, + TL_8, + TL_9, + TL_10, + TL_11, + TL_12, + TL_13, + TL_14, + TL_15, + +#endif + +}; + +bool PuzzleState::IsSameState( PuzzleState &rhs ) +{ + + for( int i=0; i<(BOARD_HEIGHT*BOARD_WIDTH); i++ ) + { + if( tiles[i] != rhs.tiles[i] ) + { + return false; + } + } + + return true; + +} + +void PuzzleState::PrintNodeInfo() +{ + char str[1024]; + sprintf( str, "%20d %20d %20d %20d\n%20d %20d %20d %20d\n%20d %20d %20d %20d\n%20d %20d %20d %20d\n", + tiles[0], + tiles[1], + tiles[2], + tiles[3], + tiles[4], + tiles[5], + tiles[6], + tiles[7], + tiles[8], + tiles[9], + tiles[10], + tiles[11], + tiles[12], + tiles[13], + tiles[14], + tiles[15] + ); + + cout << str; +} + +// Here's the heuristic function that estimates the distance from a PuzzleState +// to the Goal. + +float PuzzleState::GoalDistanceEstimate( PuzzleState &nodeGoal ) +{ + + // Return the manhattan distance + + float cost = 0.0f; + int r,c; + + for(r=0; rtiles[(y*BOARD_WIDTH)+x] == TL_SPACE ) + { + *rx = x; + *ry = y; + + return; + } + } + } + + assert( false && "Something went wrong. There's no space on the board" ); + +} + +int PuzzleState::GetMap( int x, int y, TILE *tiles ) +{ + + if( x < 0 || + x >= BOARD_WIDTH || + y < 0 || + y >= BOARD_HEIGHT + ) + return GM_OFF_BOARD; + + if( tiles[(y*BOARD_WIDTH)+x] == TL_SPACE ) + { + return GM_SPACE; + } + + return GM_TILE; +} + +// Given a node set of tiles and a set of tiles to move them into, do the move as if it was on a tile board +// note : returns false if the board wasn't changed, and simply returns the tiles as they were in the target +// spx and spy is the space position while tx and ty is the target move from position + +bool PuzzleState::LegalMove( TILE *StartTiles, TILE *TargetTiles, int spx, int spy, int tx, int ty ) +{ + + int t; + + if( GetMap( spx, spy, StartTiles ) == GM_SPACE ) + { + if( GetMap( tx, ty, StartTiles ) == GM_TILE ) + { + + // copy tiles + for( t=0; t<(BOARD_HEIGHT*BOARD_WIDTH); t++ ) + { + TargetTiles[t] = StartTiles[t]; + } + + + TargetTiles[ (ty*BOARD_WIDTH)+tx ] = StartTiles[ (spy*BOARD_WIDTH)+spx ]; + TargetTiles[ (spy*BOARD_WIDTH)+spx ] = StartTiles[ (ty*BOARD_WIDTH)+tx ]; + + return true; + } + } + + + return false; + +} + +// This generates the successors to the given PuzzleState. It uses a helper function called +// AddSuccessor to give the successors to the AStar class. The A* specific initialisation +// is done for each node internally, so here you just set the state information that +// is specific to the application +bool PuzzleState::GetSuccessors( AStarSearch *astarsearch, PuzzleState *parent_node ) +{ + PuzzleState NewNode; + + int sp_x,sp_y; + + GetSpacePosition( this, &sp_x, &sp_y ); + + bool ret; + + if( LegalMove( tiles, NewNode.tiles, sp_x, sp_y, sp_x, sp_y-1 ) == true ) + { + ret = astarsearch->AddSuccessor( NewNode ); + + if( !ret ) return false; + } + + if( LegalMove( tiles, NewNode.tiles, sp_x, sp_y, sp_x, sp_y+1 ) == true ) + { + ret = astarsearch->AddSuccessor( NewNode ); + + if( !ret ) return false; + } + + if( LegalMove( tiles, NewNode.tiles, sp_x, sp_y, sp_x-1, sp_y ) == true ) + { + ret = astarsearch->AddSuccessor( NewNode ); + + if( !ret ) return false; + } + + if( LegalMove( tiles, NewNode.tiles, sp_x, sp_y, sp_x+1, sp_y ) == true ) + { + ret = astarsearch->AddSuccessor( NewNode ); + + if( !ret ) return false; + } + + return true; +} + +// given this node, what does it cost to move to successor. In the case +// of our map the answer is the map terrain value at this node since that is +// conceptually where we're moving + +float PuzzleState::GetCost( PuzzleState &successor ) +{ + return 1.0f; // I love it when life is simple + +} + + +// Main + +int main( int argc, char *argv[] ) +{ + + cout << "STL A* 8-puzzle solver implementation\n(C)2001 Justin Heyes-Jones\n"; + + if( argc > 1 ) + { + int i = 0; + int c; + + while( (c = argv[1][i]) ) + { + if( isdigit( c ) ) + { + int num = (c - '0'); + + PuzzleState::g_start[i] = static_cast(num); + + } + + i++; + } + + + } + + // Create an instance of the search class... + + AStarSearch astarsearch; + + int NumTimesToSearch = NUM_TIMES_TO_RUN_SEARCH; + + while( NumTimesToSearch-- ) + { + + // Create a start state + PuzzleState nodeStart( PuzzleState::g_start ); + + // Define the goal state + PuzzleState nodeEnd( PuzzleState::g_goal ); + + // Set Start and goal states + astarsearch.SetStartAndGoalStates( nodeStart, nodeEnd ); + + ((PuzzleState *)PuzzleState::g_start)->PrintNodeInfo(); + + unsigned int SearchState; + + unsigned int SearchSteps = 0; + + do + { + SearchState = astarsearch.SearchStep(); + +#if DEBUG_LISTS + + float f,g,h; + + cout << "Search step " << SearchSteps << endl; + + cout << "Open:\n"; + PuzzleState *p = astarsearch.GetOpenListStart( f,g,h ); + while( p ) + { + ((PuzzleState *)p)->PrintNodeInfo(); + cout << "f: " << f << " g: " << g << " h: " << h << "\n\n"; + + p = astarsearch.GetOpenListNext( f,g,h ); + + } + + cout << "Closed:\n"; + p = astarsearch.GetClosedListStart( f,g,h ); + while( p ) + { + p->PrintNodeInfo(); + cout << "f: " << f << " g: " << g << " h: " << h << "\n\n"; + + p = astarsearch.GetClosedListNext( f,g,h ); + } + +#endif + +// Test cancel search +#if 0 + int StepCount = astarsearch.GetStepCount(); + if( StepCount == 10 ) + { + astarsearch.CancelSearch(); + } +#endif + SearchSteps++; + getchar(); + } + while( SearchState == AStarSearch::SEARCH_STATE_SEARCHING ); + + if( SearchState == AStarSearch::SEARCH_STATE_SUCCEEDED ) + { +#if DISPLAY_SOLUTION_FORWARDS + cout << "Search found goal state\n"; +#endif + PuzzleState *node = astarsearch.GetSolutionStart(); + +#if DISPLAY_SOLUTION_FORWARDS + cout << "Displaying solution\n"; +#endif + int steps = 0; + +#if DISPLAY_SOLUTION_FORWARDS + node->PrintNodeInfo(); + cout << endl; +#endif + for( ;; ) + { + node = astarsearch.GetSolutionNext(); + + if( !node ) + { + break; + } + +#if DISPLAY_SOLUTION_FORWARDS + node->PrintNodeInfo(); + cout << endl; +#endif + steps ++; + + }; + +#if DISPLAY_SOLUTION_FORWARDS + // todo move step count into main algorithm + cout << "Solution steps " << steps << endl; +#endif + +//////////// + + node = astarsearch.GetSolutionEnd(); + +#if DISPLAY_SOLUTION_BACKWARDS + cout << "Displaying reverse solution\n"; +#endif + steps = 0; + + node->PrintNodeInfo(); + cout << endl; + for( ;; ) + { + node = astarsearch.GetSolutionPrev(); + + if( !node ) + { + break; + } +#if DISPLAY_SOLUTION_BACKWARDS + node->PrintNodeInfo(); + cout << endl; +#endif + steps ++; + + }; + +#if DISPLAY_SOLUTION_BACKWARDS + cout << "Solution steps " << steps << endl; +#endif + +////////////// + + // Once you're done with the solution you can free the nodes up + astarsearch.FreeSolutionNodes(); + + } + else if( SearchState == AStarSearch::SEARCH_STATE_FAILED ) + { +#if DISPLAY_SOLUTION_INFO + cout << "Search terminated. Did not find goal state\n"; +#endif + } + else if( SearchState == AStarSearch::SEARCH_STATE_OUT_OF_MEMORY ) + { +#if DISPLAY_SOLUTION_INFO + cout << "Search terminated. Out of memory\n"; +#endif + } + + + + // Display the number of loops the search went through +#if DISPLAY_SOLUTION_INFO + cout << "SearchSteps : " << astarsearch.GetStepCount() << endl; +#endif + } + + return 0; +} + + diff --git a/cpp/makefile b/cpp/makefile index 153a494..9f26ba5 100644 --- a/cpp/makefile +++ b/cpp/makefile @@ -1,7 +1,7 @@ -all : 8puzzle findpath minpathbucharest tests +all : 8puzzle findpath minpathbucharest tests 15puzzle clean : - rm 8puzzle findpath minpathbucharest tests + rm 8puzzle findpath minpathbucharest tests 15puzzle minpathbucharest : min_path_to_Bucharest.cpp stlastar.h g++ -Wall min_path_to_Bucharest.cpp -o minpathbucharest @@ -9,6 +9,9 @@ minpathbucharest : min_path_to_Bucharest.cpp stlastar.h 8puzzle : 8puzzle.cpp stlastar.h g++ -Wall 8puzzle.cpp -o 8puzzle +15puzzle : 15puzzle.cpp stlastar.h + g++ -Wall 15puzzle.cpp -o 15puzzle + findpath : findpath.cpp stlastar.h g++ -Wall findpath.cpp -o findpath diff --git a/cpp/stlastar.h b/cpp/stlastar.h index 04ab3c4..cab38cf 100755 --- a/cpp/stlastar.h +++ b/cpp/stlastar.h @@ -44,7 +44,7 @@ using namespace std; // Fixed size memory allocator can be disabled to compare performance // Uses std new and delete instead if you turn it off -#define USE_FSA_MEMORY 1 +#define USE_FSA_MEMORY 0 // disable warning that debugging information has lines that are truncated // occurs in stl headers