Solving a maze with 4 exits from the inside

Question

Hi, I'm working on an algorithm that solves a maze from the inside, and seeks out 1 of the 4 exits on the sides, and after getting 1, it goes to the next until it has them all. The maze is always 22x22, and you only have 400 steps. I asked my teacher about using a recursive method to solve it, and he said that is probably the best way to go. But, the catch is that you don't know where the walls are, and they change every time. The rat (I'm trying to get a rat to all four exits) starts in the 4x4 box in the middle that has between 1 and 5 exits (it's different every time a maze is generated). The rat can see how far away a wall is, and you are allowed to store the positions in an array if you wish. He can also build walls and get his current x and y position.
Here's an example of what a maze looks like:
http://farm4.static.flickr.com/3528/3201086335_4556d4aed7_o.jpg
I think that's everything, any help would be greatly appreciated =]

Answer 1

code continued...
    // recursivly find the best path-of-travel
    public int[] recursePath()
        // if in an exit, kill the recursion process
        if(x==0||x==21||y==0||y==21) {int[] bestPath = new int[1]; return bestPath; }
        // x- and y- counters are to signify how many units in each direction
        // from the current real x, y that the algorithm is at
        int curX = x+xCounter;
        int curY = y+yCounter;
        // the maximum number of moves = the closestExitRange, plus however
        // many fewer/extra moves are needed so it lands EXACTLY on the exit,
        // minus the number of places generated so far.
        moveCount = closestExitRange + neededExtraMoves - spacesMoved;
        // give the bestPath a length if it is the first time running algorithm
        if(spacesMoved==0) bestPath = new int[moveCount];
        while(spacesMoved<moveCount)
            // if the algorithm will not land in an exit in EXACTlLY
            // x number of moves, edit x acordingly, and reset algorithm.
            // if there are not enough moves to make it to the exit, crear variables,
            // add 1 to extra moves, check again.
            if( spacesMoved==moveCount-1 && ((curX>1 && curX<20) || (curY>1 && curY<20)) )
                neededExtraMoves++;
                xCounter=0;
                yCounter=0;
                spacesMoved=0;
                bestPath = new int[moveCount];
                recursePath();
            // if there are not too many moves, crear variables,
            // subtract 1 from extra moves, check again.
            else if( spacesMoved<moveCount && (curX==0 || curX==21 || curY==0 || curY==21) )
                neededExtraMoves--;
                xCounter=0;
                yCounter=0;
                spacesMoved=0;
                bestPath = new int[moveCount];
                recursePath();
            // look in all directions, and find the highest value, and
            // move in that direction
            int moveDir = findFurthestWay(lookNorth, lookEast, lookSouth, lookWest);
            if(moveDir==NORTH) { yCounter--; bestPath[spacesMoved] = NORTH; }
            if(moveDir==SOUTH) { yCounter++; bestPath[spacesMoved] = SOUTH; }
            if(moveDir==WEST)  { xCounter--; bestPath[spacesMoved] = WEST;  }
            if(moveDir==EAST)  { xCounter++; bestPath[spacesMoved] = EAST;  }
//             curX = x+xCounter;
//             curY = y+yCounter;
            spacesMoved++;
            recursePath();
        //bestPath = new int[moveCount];
        return bestPath;
    // find the path that has thegreatest line of sight (in order n, e, s, w)
    public int findFurthestWay(int a, int b, int c, int d)
        int greatestNumber = 0;
        if(a>greatestNumber) greatestNumber = a;
        if(b>greatestNumber) greatestNumber = b;
        if(c>greatestNumber) greatestNumber = c;
        if(d>greatestNumber) greatestNumber = d;
        // NORTH=1, EAST=2, SOUTH=3, WEST=4
        if(a==greatestNumber) return NORTH;
        if(b==greatestNumber) return EAST;
        if(c==greatestNumber) return SOUTH;
        if(d==greatestNumber) return WEST;
        return 0;
    // reset recursePath vars.
    public void resetCounters()
        xCounter = 0;
        yCounter = 0;
        spacesMoved = 0;
        neededExtraMoves = 0;
        moveCount = 0;
        bestPath = new int[moveCount];
    // record the positions of the walls
    public void storeWallLocations()
        // Store the locations of the walls
        if(lookNorth!=100) wallLocations[x][y-lookNorth][0]=true;
        try{wallLocations[x][y-lookNorth-1][2]=true;} catch(Exception e){}
        if(lookSouth!=100) wallLocations[x][y+lookSouth][2]=true;
        try{wallLocations[x][y+lookSouth+1][0]=true;} catch(Exception e){}
        if(lookWest!=100) wallLocations[x-lookWest][y][3]=true;
        try{wallLocations[x-lookWest-1][y][1]=true;}  catch(Exception e){}
        if(lookEast!=100) wallLocations[x+lookEast][y][1]=true;
        try{wallLocations[x+lookEast+1][y][3]=true;}  catch(Exception e){}
}