why two almost same implementation is having a big execution time difference?

Question

I am trying to solve the Knight Tour problem using bactracking as given on this site.

Implementation given on the site takes about 0.49 seconds on ideone.

int solveKTUtil(int x, int y, int movei, int sol[N][N], int xMove[N],
                int yMove[N])
{
   int k, next_x, next_y;
   if (movei == N*N)
       return true;

   /* Try all next moves from the current coordinate x, y */
   for (k = 0; k < 8; k++)
   {
       next_x = x + xMove[k];
       next_y = y + yMove[k];
       if (isSafe(next_x, next_y, sol))
       {
         sol[next_x][next_y] = movei;
         if (solveKTUtil(next_x, next_y, movei+1, sol, xMove, yMove) == true)
             return true;
         else
             sol[next_x][next_y] = -1;// backtracking
       }
   }

   return false;
}

while one implemented by me which is almost same is showing time limit exceeded(more than 5 seconds) on ideone.

int generateMoves(int x, int y, int moveNum, int soln[][N], int xMoves[], int yMoves[])//making move number 'moveNum' from x and y.
{
        if(moveNum == N*N){
                return 1;
        }
        else{
                int i, nextX, nextY;
                for(i=0; i<8; ++i){
                        nextX = x + xMoves[i];
                        nextY = y + yMoves[i];

                        if(isSafe(nextX, nextY, soln)){
                                soln[nextX][nextY] = moveNum;
                                if( generateMoves(nextX, nextY, moveNum+1, soln, xMoves, yMoves) ){
                                        return 1;
                                }
                                else{
                                        soln[nextX][nextY] = -1;
                                }
                        }
                }
                return 0;
        }
}

what is executing for so long in my code?

Have you tried profiling your code to see where it spends the time? Are the `isSafe` functions identical in both cases? — Anders Abel, Jul 28 '12 at 13:57
yes, isSafe is same in both.please see my complete code here http://ideone.com/RP068 and the other code is here http://ideone.com/qfsf3 — Eight, Jul 28 '12 at 14:00
Your version of the code runs forever for some reason. Can't see an obvious reason why. I recommend going over the code again and see what the difference is. — gnobal, Jul 28 '12 at 14:07

fgb · Accepted Answer · 2012-07-28T14:20:48.577

6

Changing xMoves/yMoves seems to work: ideone. It could just be the search order causing it to find a solution earlier.

There are too many possible 63, 62, 61 etc length tours that can't reach the final remaining squares. A brute-force search would have to go through all of them in the worst-case. The algorithm that worked just got lucky by trying a sequence of moves that led to a solution early.

edited Jul 28 '12 at 14:20

answered Jul 28 '12 at 14:01

fgb

18,439
2
38
52

great...thanks a lot.can you also explain the reason of this behaviour? pls. – Eight Jul 28 '12 at 14:11

score 1 · Answer 2 · answered Jul 28 '12 at 16:30

Your post don't show the difference between your code and and the original one.
Infact, if you look at your code carefully, the only between yours and the right one is such:

int xMoves[] = {  2, 1, -1, -2, -2, -1,  1,  2 };//{2, 2,  1,  1, -1, -1, -2, -2};  
int yMoves[] = {  1, 2,  2,  1, -1, -2, -2, -1 };//{1, -1, -2, 2, -2, 2, -1,  1};

The order is different. You draw the possible moves on a paper, and you can find that the right one has an anticlockwise order, while yours is totally in disorder.
That must be the reason caused your problem.

why two almost same implementation is having a big execution time difference?

2 Answers2