Hello!
I want to write a program about tracing.
We have a 5*5 coulumn with a few black blanks.
We want to move from left sided in below of coulumn
and go to right sided in above of coulumn and we mustnot
move across black blanks.
We want the simplest and shortest way .
I hope you help me.
Thank you.
regards.

i don't know if this is the most efficient way, but one of the easy ways of doing this, are to write a program that would go through all the possibilities, then store them in an array, along with the number of moves it took (probably want to make a class for this). then, do a check to see which one is the smallest.


here's an example of the data members, but i won't write all the code for u:

class route {
private:
 int moves;
 coords *routeHead; //linked list of the directions it took
}

class coords {
private:
 int x;
 int y;
}


to go through each possibility, have a recursive function that checks to see if it can go in each direction, if it can, it calls itself. base case is it reaches the end of the maze, or it can't go anywhere but back. while it does this, it records the data into the class.

----------------------------
http://aeonofdarkness.com

natmaster is suggesting a Depth-First Search. Looking at the brief description of the problem, I'd go for a Breadth First approach, wioth a recursive fn:
Solve Routine:
==============
LET v be a set (ArrayList, Hashtable, what-have-you);
Add the starting board configuration to v;
RETURN the result of doit(v, 0);

doit Routine:
=============
Parameters:
edge: a set (ArrayList, Hashtable, what-have-you) of the current possible position(s);
n: the number of moves done so far;

LET nextEdge be an empty set;
FOREACH boardConfiguration in edge:
  IF the boardConfiguration is the goal
    RETURN n;
  LET children be the set of board configuration that may be created from boardConfiguration
  by applying all the possible moves;
  ADD to nextEdge all the element of children;
LET nn be n+1;
RETURN doit(nextEdge, nn);

HTH,
Olorin