backtracking

I've been searching for hours and haven't found a fully working solution for this kind of puzzle yet. So I followed similar problem with bishops. What I need to do is place 12 knights on the chess board in such a way, that all free squares of the board are attacked by at least one piece. The final result should look like this: The problem is that my program only tries different combinations with two last pieces and then somehow crashes. EDITED What I have done so far: #include <iostream> using namespace std; #define N 8 void fillChessBoard(int (&chessBoard)[N][N], int num); void

I'm debugging a Regular Expression ^(A+)*B over a string AAAC (example from rexegg.com) by two separate debugging tools I have access: regex101.com RegexBuddy v4 Below is the results (regex101 in the left side): The question I have is not mainly about the number of steps which is also important to me, but is how backtracks are done. Why do we see differences? (regex101 uses PCRE lib and I set RegexBuddy lib the same) A comprehensive step by step explanation is really in my favor. I wouldn't rely on either the number of steps or any debugging as a test of either backtracking or failure.

I searched the web for different solutions to the n-queens problem in Haskell but couldn't find any that could check for unsafe positions in O(1) time, like that one that you keep an array for the / diagonals and one for the \ diagonals. Most solutions I found just checked each new queen against all the previous ones. Something like this: http://www.reddit.com/r/programming/comments/62j4m/nqueens_in_haskell/ nqueens :: Int -> [[(Int,Int)]] nqueens n = foldr qu [[]] [1..n] where qu k qss = [ ((j,k):qs) | qs <- qss, j <- [1..n], all (safe (j,k)) qs ] safe (j,k) (l,m) = j /= l && k /= m && abs (j

How to calculate time complexity for these backtracking algorithms and do they have same time complexity? If different how? Kindly explain in detail and thanks for the help. 1. Hamiltonian cycle: bool hamCycleUtil(bool graph[V][V], int path[], int pos) { /* base case: If all vertices are included in Hamiltonian Cycle */ if (pos == V) { // And if there is an edge from the last included vertex to the // first vertex if ( graph[ path[pos-1] ][ path[0] ] == 1 ) return true; else return false; } // Try different vertices as a next candidate in Hamiltonian Cycle. // We don't try for 0 as we included

I code the Knight's tour algorithm in c++ using Backtracking method. But it seems too slow or stuck in infinite loop for n > 7 (bigger than 7 by 7 chessboard). The question is: What is the Time complexity for this algorithm and how can I optimize it?! The Knight's Tour problem can be stated as follows: Given a chess board with n × n squares, find a path for the knight that visits every square exactly once. Here is my code : #include <iostream> #include <iomanip> using namespace std; int counter = 1; class horse { public: horse(int); bool backtrack(int, int); void print(); private: int size;