int main(int argc, char ** argv)
{
Puzzle * puzzle = NULL;
Display * display = NULL;
if (argc > 4 || argc < 3 || strcmp(argv[1], "-g"))
{
std::cout << "Usage " << argv[0] << " -g greedness [filename]" << std::endl;
return (EXIT_SUCCESS);
}
try
{
srand(time(NULL));
Puzzle::_greedness = (atoi(argv[2]) > 0) ? atoi(argv[2]) : 1;
if (argc == 4)
puzzle = new Puzzle(argv[3]);
else if (argc == 3)
puzzle = new Puzzle();
puzzle->isSolvable();
display = new Display(puzzle);
display->render();
}
catch (std::exception & e)
{
std::cout << e.what() << std::endl;
}
if (display)
delete display;
return (EXIT_SUCCESS);
}
int manhattan(const Puzzle& state, const Puzzle& solution) {
int result = -1;
/*
* These loops compare two vectors piece by piece,
* finding the row and column indeces for corresponding
* pieces, and adding the magnitudes of the differences.
*
* This is presently O(n^2).
* TODO: investigate O(n) solution
*/
if(state.get_width() == solution.get_width()) {
size_t width = state.get_width();
int i = 0;
for(TileIt it1 = state.tiles.begin(); it1 != state.tiles.end(); it1++, i++) {
if(*it1 != 0) {
int j = 0;
for(TileIt it2 = solution.tiles.begin(); *it1 != *it2; it2++, j++);
int r1 = i / width;
int r2 = j / width;
int c1 = i % width;
int c2 = j % width;
result += abs(r2 - r1) + abs(c2 - c1);
}
}
}
return result;
}
Game CustomGame::createGame(int difficulty, int symmetry) {
if (! createSKGraphObject()) {
return Game();
}
Puzzle* puzzle = new Puzzle(m_graph, true);
puzzle->init(difficulty, symmetry);
return Game(puzzle);
}
Game CustomGame::startEmpty() {
if (! createSKGraphObject()) {
return Game();
}
Puzzle* puzzle = new Puzzle(m_graph, false);
puzzle->init();
return Game(puzzle);
}
int main(int argc, char **argv)
{
char Name = 'M';
std::string taq = "TaquinA5_2.txt";
if (argc == 3)
{
std::ifstream infile;
infile.open(argv[2]);
if (!infile.is_open())
{
std::cout << "Error: file <" << argv[2] << ">" << " not found" << std::endl;
return (-1);
}
infile.close();
taq = argv[2];
FileLoader F;
std::string S;
Puzzle P;
SolutionGenerator SG;
short unsigned int** Tab;
clock_t timeDeb, timeEnd;
std::list<Puzzle> OpenedList, ClosedList;
int x = 0, y = 0, fg = -42;
timeDeb = clock();
DisplayLogo();
F.LoadFile(taq.c_str(), S);
std::istringstream In(S);
P.SetAlgo(Name);
Tab = P.CreatePuzzle(S);
std::list<Puzzle>::iterator FirstPuzzle;
OpenedList.push_back(P);
while (fg != 0 && !OpenedList.empty())
{
FirstPuzzle = OpenedList.begin();
fg = Resume(FirstPuzzle, OpenedList, ClosedList, timeEnd);
ProcessUp(FirstPuzzle, OpenedList, ClosedList);
ProcessDown(FirstPuzzle, OpenedList, ClosedList);
ProcessRight(FirstPuzzle, OpenedList, ClosedList);
ProcessLeft(FirstPuzzle, OpenedList, ClosedList);
(*FirstPuzzle).ClearListTab();
ClosedList.push_back(*FirstPuzzle);
OpenedList.erase(FirstPuzzle);
}
if (fg != 0)
std::cout << "NO SOLUTION FOR THIS TAQUIN!!!" << std::endl;
std::cout << "CLOSED LIST NUMBER OF CONTENTS : \t\t[" << ClosedList.size() << "]"<< std::endl;
std::cout << "TIME ELAPSED : \t\t[" << static_cast<double>(timeEnd - timeDeb) << "] ms." << std::endl;
ShowNbMoves();
std::cout << "Cleaning..." << std::endl;
Clean(OpenedList, ClosedList);
std::cout << "Clean done" << std::endl;
}
return (0);
}
int main(int argc, char** argv)
{
freopen("CON", "w", stdout); // redirects stdout because SDL redirects it to a file.
/* Parsing the input parameters. */
if (argc < 6)
{
std::cout << "Missing some input parametr. Needed at least 5 but got only " << argc - 1 << std::endl;
return -1;
}
if (!initGraphics(RESX, RESY)) return -1;
renderScene();
displayVFB(vfb);
try
{
Puzzle puzzle;
if (!puzzle.loadMap(argv[1]))
throw "Something is wrong with the map file!";
puzzle.setMonsterAndFoodCoords(fromStringToInt(argv[2]), fromStringToInt(argv[3]), fromStringToInt(argv[4]), fromStringToInt(argv[5]));
// The flag for the SDL visualization
if (argc >= 7)
{
puzzle.setVisualizationFlag(fromStringToInt(argv[6]));
}
// The flag for the SDL visualization
if (argc >= 8)
{
puzzle.setDelay(fromStringToInt(argv[7]));
}
puzzle.printMap(std::cout);
puzzle.solveAndVizualize(std::cout);
puzzle.visualizeThePath();
puzzle.basicVisualizePath(std::cout);
puzzle.printFormatedPath(std::cout);
}
catch (const char * msg)
{
std::cout << "Error: " << msg << std::endl;
}
catch (const string msg)
{
std::cout << "Error: " << msg << std::endl;
}
waitForUserExit();
closeGraphics();
return 0;
}
Game RoxdokuGame::createGame(int difficulty, int symmetry) {
if(!m_graph) {
m_graph = new SKGraph(m_order, TypeRoxdoku);
m_graph->initRoxdoku();
}
Puzzle* puzzle = new Puzzle(m_graph, true);
puzzle->init(difficulty, symmetry);
return Game(puzzle);
}
Game RoxdokuGame::startEmpty() {
if(!m_graph) {
m_graph = new SKGraph(m_order, TypeRoxdoku);
m_graph->initRoxdoku();
}
Puzzle* puzzle = new Puzzle(m_graph, false);
puzzle->init();
return Game(puzzle);
}
int main(int argc, char** argv)
{
Puzzle test;
Puzzle fit;
srand(time(NULL));
cin >> test;
GeneticAlgorithm tryit(test, atoi(argv[1]), atoi(argv[2]));
//GeneticAlgorithm tryit(test, POPSIZE, MAXGENS);
fit = tryit.evolve();
fit.display();
cout << "Fitness: " << fit.fitness() << endl;
return (EXIT_SUCCESS);
}
/*
* These are the three examined heuristic functions.
* displaced(...) counts how many tiles are out of place
* manhattan(...) determines how far away each tile is from
* its correct location, as specified in the solution.
* sumdisman(...) simply sums displaced(...) and manhattan(...).
*/
int displaced(const Puzzle& state, const Puzzle& solution) {
int result = -1;
if(state.get_width() == solution.get_width()) {
result = 0;
for(TileIt it1 = state.tiles.begin(), it2 = solution.tiles.begin(); it1 != state.tiles.end(); it1++, it2++) {
if(*it1 != 0 && *it1 != *it2) {
result++;
}
}
}
return result;
}
void PuzzlesDraw(const Puzzle & pzl, const Surface & sf, s16 dstx, s16 dsty)
{
Display & display = Display::Get();
Cursor & cursor = Cursor::Get();
// show all for debug
if(IS_DEVEL()) return;
u8 alpha = 250;
u32 ticket = 0;
LocalEvent & le = LocalEvent::Get();
while(le.HandleEvents() && 0 < alpha)
{
if(Game::ShouldAnimateInfrequent(ticket, 1))
{
cursor.Hide();
display.Blit(sf, dstx, dsty);
for(size_t ii = 0; ii < pzl.size(); ++ii)
{
const Sprite & piece = AGG::GetICN(ICN::PUZZLE, ii);
if(pzl.test(ii))
{
Surface fade(piece.w(), piece.h());
fade.SetColorKey();
fade.Blit(piece);
fade.SetAlpha(alpha);
if(Settings::Get().QVGA())
display.Blit(fade, dstx + 8 + piece.x() - BORDERWIDTH, dsty + 8 + piece.y() - BORDERWIDTH);
else
display.Blit(fade, dstx + piece.x() - BORDERWIDTH, dsty + piece.y() - BORDERWIDTH);
}
else
{
if(Settings::Get().QVGA())
display.Blit(piece, dstx + 8 + piece.x() - BORDERWIDTH, dsty + 8 + piece.y() - BORDERWIDTH);
else
display.Blit(piece, dstx + piece.x() - BORDERWIDTH, dsty + piece.y() - BORDERWIDTH);
}
}
cursor.Show();
display.Flip();
alpha -= 10;
}
++ticket;
}
cursor.Hide();
}
void ZoneOpenRandomTiles(Puzzle & pzl, u8 & opens, const u8* it1, const u8* it2)
{
std::vector<u8> values;
values.reserve(25);
const u8* it = NULL;
while(opens)
{
values.clear();
it = it1;
while(it && it2 && it <= it2){ if(! pzl.test(*it)) values.push_back(*it); ++it; }
if(values.empty()) break;
pzl.set(*Rand::Get(values));
--opens;
}
}
void printAndSolve( Puzzle sudoku ) {
cout << "\nThe given puzzle looks like this: \n\n";
sudoku.printBoard();
if (!sudoku.solve()) {
printf("Cannot solve puzzle\n");
exit(0);
}
cout << "\n\nThe solved puzzle looks like this: \n\n";
sudoku.printBoard();
cout << "\n\n";
}
inline GridPoint* PuzzleSolverInterface::getMostConstrainedHole(
const int* remainingShapeList,
int numRemainingShapes,
bool estimate)
{
return puzzle->getMostConstrainedHole(remainingShapeList, numRemainingShapes, estimate);
}
void outputExpanding(Puzzle puzzle)
{
printf("The best state to expand is ...:\n");
puzzle.output();
printf("Expanding this node..\n");
}
void System::Reset()
{
GameOver = false;
GameLevel = 1;
GameScore = 0;
GameSpeed = GAME_STARTING_SPEED;
s_puzzle.Reset();
}
int main(){
Puzzle sudoku;
cin >> sudoku;
cout << "Unsolved Puzzle:" << endl;
sudoku.display();
cout << endl;
//Solve returns true if solved, false if not.
if (sudoku.solve(0, 0)) {
cout << "Solved Puzzle:" << endl;
sudoku.display();
cout << endl;
}
else {
cout << "Puzzle is unsolvable." << endl;
}
return 0;
}
void System::Start()
{
if (GameOver)
{
System::Reset();
}
s_puzzle.Start();
}
int RunPuzzleSolver(int argc, char **argv)
{
printf("usage: RunPuzzleSolver fnameBoard heuristic tmax fnameMoves\n");
const char *fnameIn = argc > 1 ? argv[1] : "puzzle.txt";
const char *hname = argc > 2 ? argv[2] : NULL;
const double tmax = argc > 3 ? atof(argv[3]) : 3.0;
const char *fnameOut= argc > 4 ? argv[4] : "moves.txt";
printf("..using fnameBoard = %s\n", fnameIn);
printf("..using heuristic = %s\n", hname);
printf("..using tmax = %f\n", tmax);
printf("..using fnameMoves = %s\n", fnameOut);
Puzzle puzzle;
Puzzle::Board *b = puzzle.ReadBoard(fnameIn);
PuzzleSolver solver;
PuzzleHeuristic *h = NULL;
std::vector<Puzzle::Move> moves;
if(hname == NULL)
h = new PuzzleHeuristic();
else if(strcmp(hname, "H1") == 0)
h = new PuzzleHeuristic1();
else if(strcmp(hname, "H2") == 0)
h = new PuzzleHeuristic2();
else if(strcmp(hname, "H3") == 0)
h = new PuzzleHeuristic3();
Utils::Timer::Clock clk;
Utils::Timer::Start(&clk);
const bool solved = solver.Solve(&puzzle, h, b, tmax, &moves);
printf("..solved = %d nrMoves = %d time = %f\n", solved, (int) moves.size(), Utils::Timer::Elapsed(&clk));
printf("..checking solution\n");
for(int i = 0; i < (int) moves.size(); ++i)
puzzle.MakeMove(b, moves[i]);
if(puzzle.IsSolved(b) == false)
{
printf("..did not reach goal configuration, see\n");
puzzle.PrintBoard(NULL, b);
}
else
printf("..ok\n");
puzzle.PrintMoves(fnameOut, &moves);
puzzle.DeleteBoard(b);
delete h;
return 0;
}
Puzzle PuzzleGenerator::GeneratePuzzle()
{
timer.StartTimer();
maxtime = 58.0; // to make sure we don't exceed a minute
// Declare variables for Simulated Annealing Algorithm
double startingTemp;
double alpha;
double epsilon;
// Determine if puzzle is "large" or not (so we can adjust how the algorithm performs)
if (nRows*nColumns >= 80 || nRows*nColumns*(maxVal - minVal - 1) > 500)
{
startingTemp = 100;
alpha = 0.9999;
epsilon = 0.001;
}
else
{
startingTemp = 100;
alpha = 0.999;
epsilon = 0.001;
}
Puzzle startingPuzzle(nRows, nColumns, minVal, maxVal);
Puzzle bestPuzzle = SimulatedAnnealing_Exp(startingPuzzle, startingTemp, alpha, epsilon);
int i = 0;
while (timer.GetElapsedTime() < maxtime)
{
startingPuzzle = Puzzle(nRows, nColumns, minVal, maxVal);
Puzzle p = SimulatedAnnealing_Exp(startingPuzzle, startingTemp, alpha, epsilon);
if (p.GetValue() > bestPuzzle.GetValue())
{
bestPuzzle = p;
}
i++;
}
return bestPuzzle;
}
Puzzle PuzzleGenerator::SimulatedAnnealing_Linear(Puzzle p, double temp_start, double delta, double epsilon)
{
// Function that uses simulated annealing algorithm to find best value puzzle.
// TEMP_START = initial temperature
// DELTA = amount that temperature decreases per iteration
// returns the best puzzle found
Puzzle current = p;
// Keep track of the time so we don't exceed it.
Timer t;
t.StartTimer();
int i = 0; // iteration counter (for debugging)
double temperature = temp_start;
while (temperature > epsilon)
{
//printf ("\nSIMULATED ANNEALING ITERATION %i\n", i);
// get random successor
Puzzle successor = current.GetRandomSuccessor();
//printf ("current value = %i\n", current.GetValue());
//printf ("successor value = %i\n", successor.GetValue());
//printf ("temperature = %f\n", temperature);
// if successor is a "good" move accept it
if (successor.GetValue() > current.GetValue())
{
//printf("successor value > current value...ACCEPTED!\n");
current = successor;
}
else // otherwise accept the move with probability of e^(deltaE/temperature)
{
int deltaE = successor.GetValue() - current.GetValue(); // calculate delta E
//printf("deltaE = %i\n", deltaE);
double randVal = (rand() % 1000) / 1000.0; // generate random value between (0,1)
//printf("randVal = %f\n", randVal);
double thresh = exp(deltaE/temperature);
//printf("thresh = %f\n", thresh);
if (randVal < thresh)
{
//printf("successor value randomly ACCEPTED\n");
current = successor;
}
}
// cool temperature each iteration
temperature -= delta;
// increment iteration counter
i++;
}
return current;
}
int
main( int argc, char** argv )
{
if ( argc < 2 )
{
std::cerr << "Usage: " << argv[0] << " <puzzle.txt>" << std::endl;
return 1;
}
Puzzle* puzzle = new Puzzle( argv[1] );
puzzle->print();
Solver* solver = new Solver;
solver->solve( *puzzle, true );
delete solver;
delete puzzle;
return 0;
}
bool PartialSolver::partiallyCorrect(Puzzle& puzzle)
{
for(int row=0; row<number; row++)
{
if(puzzle.row[row].first!=0)
{
vector<SkyScraper*> left = puzzle.getRow(row);
if(puzzle.row[row].first<partiallyFinished(left))
{
return false;
}
}
if(puzzle.row[row].second!=0)
{
vector<SkyScraper*> right = puzzle.getRow(row,true);
if(puzzle.row[row].second<partiallyFinished(right))
{
return false;
}
}
}
for(int col=0; col<number; col++)
{
if(puzzle.col[col].first!=0)
{
vector<SkyScraper*> top = puzzle.getColumn(col);
if(puzzle.col[col].first<partiallyFinished(top))
{
return false;
}
}
if(puzzle.col[col].second!=0)
{
vector<SkyScraper*> bottom = puzzle.getColumn(col,true);
if(puzzle.col[col].second<partiallyFinished(bottom))
{
return false;
}
}
}
return true;
}
void PartialSolver::solve()
{
while(!puzzles.empty())
{
Puzzle& front = puzzles.front();
///Clear points to find points for next puzzle
points.clear();
findPoints(front.puzzle);
list< pair<int,int> >::iterator it = points.begin();
for(;it!=points.end(); it++)
{
int row = (*it).first;
int col = (*it).second;
Puzzle back = Puzzle(front);
try
{
back.set(row, col, variable);
back.solve();
if(back.complete())
{
if(back.correct())
{
solved.push_back(back);
}
else
{
incorrect.push_back(back);
}
}
else
{
///If the puzzle is still partially correct continue search
if(partiallyCorrect(back))
puzzles.push_back(back);
}
} catch (bool& value) {
//incorrect.push_back(back);
}
}
puzzles.pop_front();
}
}
void d(Puzzle p)
{
for(int i = 0; i < p.size(); i++)
{
for(int j = 0; j < p[i].size(); j++)
{
printf("%5d", p[i][j]);
}
cout << endl;
}
}
// Utility for run solver and profiling
static void SolvePuzzle(Puzzle& p) {
std::chrono::time_point<HighResClock> start, end;
start = HighResClock::now();
PuzzleSolver ps(p, 1);
ps.Solve();
end = HighResClock::now();
auto ms = std::chrono::duration_cast<MilliSecond>(end - start);
std::cout << p.GetName() << " solved in " << ms.count() << " ms" << std::endl;
// Draw the first solution
ps.GetPaths()[0].Draw();
}
Puzzle *Puzzle::moveLeft(){
Puzzle *p = new Puzzle(*this);
if(x0 > 0){
p->board[y0][x0] = p->board[y0][x0-1];
p->board[y0][x0-1] = 0;
p->x0--;
p->path = path + "L";
p->pathLength = pathLength + 1;
p->depth = depth + 1; //incorrect
}
p->strBoard = p->toString();
return p;
}
Puzzle *Puzzle::moveUp(){
Puzzle *p = new Puzzle(*this);
if(y0 > 0){
p->board[y0][x0] = p->board[y0-1][x0];
p->board[y0-1][x0] = 0;
p->y0--;
p->path = path + "U";
p->pathLength = pathLength + 1;
p->depth = depth + 1;
}
p->strBoard = p->toString();
return p;
}
Puzzle *Puzzle::moveDown(){
Puzzle *p = new Puzzle(*this);
if(y0 < 2){
p->board[y0][x0] = p->board[y0+1][x0];
p->board[y0+1][x0] = 0;
p->y0++;
p->path = path + "D";
p->pathLength = pathLength + 1;
p->depth = depth + 1;
}
p->strBoard = p->toString();
return p;
}
void Puzzle::raiseBlocks(CCNode* sender, void* pData)
{
Puzzle *p = (Puzzle *)pData;
if (p->extraction->max >= p->numsprites) {
for (int i = 0; i < p->numsprites; i++)
{
int rnumb = p->extraction->extract();
int randX = rnumb % p->numCellX;
int randY = rnumb / p->numCellX;
p->cellpos[i].set(randX, randY);
}
for (int i = 0; i < p->numsprites; i++) {
p->cell[i]->setDisplayFrame(p->cellframe);
p->cell[i]->setPosition(ccp(dimX*p->cellpos[i].x, dimY*p->cellpos[i].y));
p->layer->addChild(p->cell[i]);
//action transition
p->cell[i]->setScale(0.1);
CCScaleTo *scaleup = CCScaleTo::actionWithDuration(0.25, 1);
CCAction *scaleup_ = CCEaseElasticOut::actionWithAction(scaleup);
p->cell[i]->runAction(scaleup_);
}
//schedule
CCFiniteTimeAction *scheduled_action = CCSequence::actions(CCDelayTime::actionWithDuration(p->t_duration),
CCCallFuncND::actionWithTarget(p->layer, callfuncND_selector(Puzzle::lowerBlocks), pData),
NULL);
p->layer->runAction(scheduled_action);
}
else
{
p->drawResultImage();
//cells over
}
}
