Поиск кратчайшего пути в матрице или установка факта, что такового не существует

i=1..n-m
  j=1..n-m {
    flag=true
    k=i..i+m
      l=j..j+m
        if(a[k,l]= * ){flag=false}
    if(flag){b[i,j]= . }
    else {b[i,j]= * }
    }

    char *pMatrix = NULL;
    pMatrix = new char[(x_count + 1) * (x_count + 1)];
    for(int i = 0; i < x_count ; ++i)
    {
        for(int j = 0; j < x_count; ++j)
        {
            pMatrix[x_count  * i + j] = fgetc(pFile);
        }
 
        fgetc(pFile);
    }

char *pMatrixConvert = new char[(x_count - y_count) * (x_count - y_count) ];
 
void MatrixConvert(char * pMatrix, char * pMatrixConvert, int x_count, int raft)
{
    for (int i = 0; i < (x_count - raft); ++i )
    {
        for (int j = 0; j < (x_count - raft) ; ++j)
        {
            bool flag = true;
            for (int k = i ; k <(i + raft) ; ++k)
            {
                for (int l = j ; l < (j + raft); ++l )
                {
                    if (pMatrix[x_count*k + l] == '*')
                        flag = false;
                }
            }
            if (flag)
            {
                pMatrixConvert[(x_count - raft)*i + j] = '.';
            }
            else
            {
                pMatrixConvert[(x_count - raft)*i + j] = '*';
            }
        }
    }
}

bool IsSolve(int x_count, char *pMatrix, int * pMatrixRes)
{
    
    for(int i = 0; i < x_count ; ++i)
    {
        for(int j = 0; j < x_count; ++j)
        {
            pMatrixRes[x_count * i + j] = 0;
        }
    }
    pMatrixRes[0] = 0;
    bool noSolution = true;
    int dx[] = {1, 0 , -1, 0};
    int dy[] = {0, -1, 0, 1};
    int xf = x_count - 1;
    int yf = x_count - 1;
    int n = 0;
    do
    {
        noSolution = true;
        for (int i = 0; i < x_count ; ++i)
        {
            for (int j = 0; j < x_count; ++j)
            {
                if (pMatrixRes[x_count * i + j] == n )
                {
                    for (int k = 0; k < 4; ++k)
                    {
                        if (CanGo(i, j, dx[k], dy[k], x_count, x_count, pMatrix, x_count) &&
                            pMatrixRes[x_count * (i + dx[k]) + (j + dy[k]) ] == 0)
                        {
                            noSolution = false;
                            pMatrixRes[x_count * (i + dx[k]) + (j + dy[k])] = n + 1;
                            if ((i + dx[k] == xf) && (j + dy[k] == yf))
                            {
                                return true;
                            }
                        }   
                    }
                }
                n++;
            }
        }
    }while (noSolution);
    return false;
}

bool Wave(char *pMatrix, int * pMatrixRes, int border, int & res, int raft)
{
    for (int i = 0 ; i < border ; ++i)
    {
        for (int j = 0; j < border ; ++j)
        {
            pMatrixRes[i * border + j] = 0;
        }
    }
    
    pMatrixRes[0] = 1;
    int  n = 1;
    bool noSolution = true;
    while (noSolution) 
    {
        for (int i = 0; i < border ; ++i)
        {
            for (int j = 0; j < border ; ++j)
            {
                if (pMatrixRes[i * border + j] == n)
                {
                    /*for (int k = 0; k < 4 ; ++k)
                    {*/
                        if (CanGo(i, j, 1, 0, border,pMatrix) && 
                            (pMatrixRes[(i + 1) * border + (j + 0)] == 0))
                        {
                            PrintMatrix(pMatrixRes, border);
                            noSolution = false;
                            pMatrixRes[(i + 1) * border + (j + 0)] = n + 1;
                            if ((i + 1) == (border - 1) && ((j + 0) == (border - 1)))
                            {
                                res = n;
                                return true;
                            }
                        }
                        if (CanGo(i, j, -1, 0, border,pMatrix) && 
                            (pMatrixRes[(i - 1) * border + (j + 0)] == 0))
                        {
                            PrintMatrix(pMatrixRes, border);
                            noSolution = false;
                            pMatrixRes[(i - 1) * border + (j + 0)] = n + 1;
                            if ((i - 1) == (border - 1) && ((j + 0) == (border - 1)))
                            {
                                res = n;
                                return true;
                            }
                        }
                        if (CanGo(i, j, 0, -1, border,pMatrix) && 
                            (pMatrixRes[(i + 0) * border + (j - 1)] == 0))
                        {
                            PrintMatrix(pMatrixRes, border);
                            noSolution = false;
                            pMatrixRes[(i + 0) * border + (j - 1)] = n + 1;
                            if ((i + 0) == (border - 1) && ((j - 1) == (border - 1)))
                            {
                                res = n;
                                return true;
                            }
                        }
                        if (CanGo(i, j, 0, 1, border,pMatrix) && 
                            (pMatrixRes[(i + 0) * border + (j + 1)] == 0))
                        {
                            PrintMatrix(pMatrixRes, border);
                            noSolution = false;
                            pMatrixRes[(i + 0) * border + (j + 1)] = n + 1;
                            if ((i + 0) == (border - 1) && ((j + 1) == (border - 1)))
                            {
                                res = n;
                                return true;
                            }
                        }
                        //}
                //  }
                    n++;
                }
            }
        }
    }
    return false;
}