Попасть из одной точки двумерного массива в другую

#include <iostream>
#include <vector>
 
using namespace std;
 
int main()
{
    int r = 1;
 
 vector<int> v;
 for(int i=0;i<r*rand()%10;i++)
     v.push_back(rand()%15);
 vector<int>::iterator beg=v.begin();
 vector<int>::iterator end=v.end();
 while(beg!=end)
     cout<< *(beg++)<<' ';
 cout<<endl;
 system("pause");
 return 0;
}

for(int i=0;i<r*rand()%10;i++)

#include <iostream>
#include <vector>
 
using namespace std;
 
int main()
{
    int const n=10;
    //vector<int> SumVec; по идее это должен быть вектор в который мы записываем значения, по которым прошли. 
    vector<vector<int> > MainVec(n); 
    cout<<"Our matrix"<<endl;
    for (int i=0;i<n;cout<<endl,++i) 
    { 
        int m=rand()%10+4; 
        for(int j=0;j<m;cout<<"  ",++j)
        {
            MainVec[i].push_back(rand()%10);
            cout<<MainVec[i][j];
        }
    }
 
 
 
    system("pause");    
    return 0;
}

#include <iostream>
#include <vector>
 
using namespace std;
 
//////////////////////////////////////////////////////////////////////////
 
struct Index
{
   static const Index INVALID_INDEX;
   int _x;
   int _y;   
   Index( const int x, const int y );
   Index( const Index& copy );
   bool operator==( const Index& right ) const;
   Index operator+( const Index& right ) const;
};
 
const Index Index::INVALID_INDEX = {-1,-1};
 
//////////////////////////////////////////////////////////////////////////
 
Index::Index( const int x, const int y )
{
   _x = x;
   _y = y;
}
Index::Index( const Index& copy )
{
   _x = copy._x;
   _y = copy._y;
}
bool Index::operator==( const Index& right ) const
{
   return _x == right._x && _y == right._y;
}
Index Index::operator+( const Index& right ) const
{
   Index result( *this );
   result._x += right._x;
   result._y += right._y;
   return result;
}
 
//////////////////////////////////////////////////////////////////////////
 
class Field
{
public:
   typedef vector<Index>                     IndexArray;
 
private:
   vector<vector<int>>                       m_field;
 
   //recursiveVariables
   IndexArray                                m_bestWay;
 
 
   bool                                      isCorrectIndex( const Index& index );
   void                                      recursiveSeach( const Index& from, const Index& to, IndexArray& way );
 
 
public:
   Field();
 
   IndexArray                                getWayFromTo( const Index& from, const Index& to );
   void                                      show();
};
 
//////////////////////////////////////////////////////////////////////////
 
 
Field::Field()
{
   const int n = 10;
   m_field.resize( n );
   for(int i = 0; i < n; ++i)
   {
      int m = rand() % 10 + 4;
      for(int j = 0; j < m; ++j)
      {
         m_field[i].push_back( rand() % 10 );        
      }
   }
 
}
bool Field::isCorrectIndex( const Index& index )
{
   bool result = true;
 
   const int& y = index._y;
   const int& x = index._x;
 
   if(m_field.size() < y && y >= 0 && !m_field.empty())
   {
      if(m_field[y].size() < x && x >= 0 && !m_field[y].empty())
      {
         result = true;
      }
      else
         result = false;
   }
   else
      result = false;
   return true;
}
 
 
void Field::recursiveSeach( const Index& from, const Index& to, IndexArray& way )
{
   if(!isCorrectIndex( from ) || !isCorrectIndex( to ))
       return;     // incorrect parametrs
   
 
 
   //////////////////////////////////////////////////////////////////////////
   // recuirsive end
   //////////////////////////////////////////////////////////////////////////
   if(from == to)
   {
      if(!m_bestWay.empty())
      {
         if(m_bestWay.size() > way.size())
         {
            m_bestWay = way;
         }
      }
      else
         m_bestWay = way;
   }
   //////////////////////////////////////////////////////////////////////////
   // recuirsive call
   //////////////////////////////////////////////////////////////////////////
   else
   {
      way.push_back( from );
 
      recursiveSeach( from + Index(-1,0), to, way );
      recursiveSeach( from + Index(+1,0), to, way );
      recursiveSeach( from + Index(0,-1), to, way );
      recursiveSeach( from + Index(0,+1), to, way );
 
   }
}
 
Field::IndexArray Field::getWayFromTo( const Index& from, const Index& to )
{
   IndexArray result;
 
   // algorithm
   if(isCorrectIndex( from ))
   {
      if(isCorrectIndex( to ))
      {
 
      }
      else
         result.push_back( Index::INVALID_INDEX );
   }
   else
      result.push_back( Index::INVALID_INDEX );
 
   return result;
}
 
void Field::show()
{
   for(auto& it : m_field)
   {
      for(auto& q : it)
      {
         cout << q << " ";
      }
      cout << endl;
   }
}
 
//////////////////////////////////////////////////////////////////////////
 
int main()
{
   Field a;
 
   a.show();
 
   system( "pause" );
   return 0;
}