布线问题

#include <iostream>
#include <list>
#include <stdlib.h>
#define  n 6   //size of maze
using namespace std;

int grid[n+2][n+2];  //we set the border for the maze
 struct position  //this struct is used to record the path
{
    int row;
    int col;
    position(int a, int b) //constructor function
    {
        row = a;
        col = b;
    }

    position()
    {
    }
    bool isEqualWith(position &another)  //determine whether two struction is equal
    {
        if(row==another.row&&col==another.col)
            return true;
        else
            return false;
    }
};

bool findPath(position start, position finish, int &PathLen, position *&path)  //pathlen is the len of the path, path is the array record path;
{
    if(start.isEqualWith(finish))  //if the atart point is equal to finish point, we end the function
    {
        PathLen=0;
        cout << "start point is the same as end point";
        return true;
    }

    for(int i=0; i<=n+1; i++)  //set wall for maze
    {
        grid[0][i] = grid[n+1][i] = -2;
    }
    for(int i=0; i<=n+1; i++)
    {
        grid[i][0] = grid[i][n+1] = -2;
    }

    position offset[4];
    offset[0].col = 1;
    offset[0].row = 0;  //the direction is right
    offset[1].col = 0;
    offset[1].row=1;  //the direction is down
    offset[2].col = -1;
    offset[2].row = 0;  //left
    offset[3].col = 0;
    offset[3].row = -1;  //up

    int numofNbr = 4;  //the number of directins
    position here, nbr;  // here is the extension box, nbr is the extended square
    here.row = start.row; //we explore the target from the start point
    here.col = start.col;
    grid[start.row][start.col] = 0;  //the distance of start point is zero
    list <position> Q;  //queue
    while(true)
    {
        for(int i=0; i<numofNbr; i++)
        {
            nbr.row = here.row + offset[i].row;
            nbr.col = here.col + offset[i].col;
            if(grid[nbr.row][nbr.col]==-1)  //if the node can be extended, we push if into Q, and set the distance of it to one;
            {
             grid[nbr.row][nbr.col] = grid[here.row][here.col] + 1;  
              Q.push_back(nbr);
            }
            if(nbr.row==finish.row&&nbr.col==finish.col)  //when we find the target, we get out of tha circulation, i use the goto sentence, because the break sentence can only jump out one level circulation, the offical explanation for break statement is "A break causes the innermost enclosing loop or switch to be exited immediately."
               goto next;
        }
        if(Q.empty())
            return false;
        here = Q.front();
        Q.pop_front();
    }

    next: PathLen = grid[finish.row][finish.col];
    path = (position*)malloc(sizeof(position)*PathLen+1);  //the length of path is pathlen+1, because the position information we need to record is pethlen+1
    here = finish;
    for(int j=PathLen; j>=0; j--)
    {
        path[j]=here;
        for(int i=0; i<numofNbr; i++)
        {
            nbr.row = here.row + offset[i].row;
            nbr.col = here.col + offset[i].col;
            if(grid[nbr.row][nbr.col]==j-1)  //if the neighboring point value is equal to the value of now minus 0ne, the neighboring point is last point we need to find
                break;
        }
        here = nbr;
    }

    return true;
}
int main()
{
    for(int i=0; i<n+2; i++)
        for(int j=0; j<n+2; j++)
    {
        grid[i][j]=-1;
    }

    grid[4][5]=-2;
    int a;
    position* path = NULL;
    findPath(position(4,4), position(4,6), a, path);
            for(int i=0; i<a+1; i++)
    {
        cout << path[i].row << " " << path[i].col << endl;
    }
    return 0;
}