Recursion to find shortest path

[wicodly]

Long question.
I'm finishing a class project and I'm in desperate need of help. The goal is practicing recursion. Were given a text file like this:

5 5
6 2 3 44 15
1 7 2 9 10
11 1 5 14 12
5 17 2 1 20
21 7 33 4 25
where the first row is the row and column size. We only can move right or down to make it easy for us. The output would look like:

50 > > v v v > v >

My header file:

    #ifndef MATRIX_H
    #define MATRIX_H
    
    #include <string>
    #include <iostream>
    using namespace std;
    
    class Matrix
    {
    	public:
    		Matrix(int pRows = 10, int pCols = 10);
    		Matrix(string file);
    		~Matrix();
    
    		void resize(int pRows, int pCols);
    		void print(ostream &sout = cout) const;
    
    		bool loadFile(string file);
    		bool saveFile(string file) const;
    
    		int getRows() const;
    		int getCols() const;
    
    		void set(int row, int col, int value);
    		int get(int row, int col) const;
    
    		const int *operator[](int i) const;
    		int *operator[](int i);
    	private:
    		int **array;
    		int rows, cols;
        };
    
        #endif 

Includers

    #include <iostream>
    #include <fstream>
    #include "matrix.h"
    using namespace std;
    
    Matrix::Matrix(int pRows, int pCols)
    {
    	array = NULL;
    	resize(pRows, pCols);
    }
    
    Matrix::Matrix(string file)
    {
    	array = NULL;
    	loadFile(file);
    }
    
    Matrix::~Matrix()
    {
    	// Deallocate each row
    	for(int i = 0; i < rows; i++)
    	{
    		delete[] array[i];
    	}
    	// Deallocate the array of rows
    	delete[] array;
    }
    
    void Matrix::resize(int pRows, int pCols)
    {
    	// Deallocate old rows
    	if(array != NULL)
    	{
    		for(int i = 0; i < rows; i++)
    		{
    			delete[] array[i];
    		}
    		delete[] array;
    		array = NULL;
    	}
    
    	// Save new rows
    	rows = pRows;
    	cols = pCols;
    	
    	// Allocate an array of rows
    	array = new int *[rows];
    	for(int i = 0; i < rows; i++)
    	{
    		// Allocate each row
    		array[i] = new int[cols];
    		
    		// Initialize each row
    		for(int j = 0; j < cols; j++)
    		{
    			array[i][j] = 0;
    		}
    	}	
    }
    
    bool Matrix::loadFile(string file)
    {
    	ifstream fin;
    	fin.open(file.c_str());
    
    	int r, c;
    
    	if(!fin.good())
    	{
    		fin.close();
    		return false;
    	}
    	
    	fin >> r >> c;
    	if(r > 0 && c > 0)
    	{
    		resize(r, c);
    		for(int i = 0; i < r; i++)
    		{
    			for(int j = 0; j < c; j++)
    			{
    				if(!fin.good())
    				{
    					fin.close();
    					return false;
    				}
    				fin >> array[i][j];
    			}
    		}
    	}
    
    	fin.close();
    	return true;
    }
    
    bool Matrix::saveFile(string file) const
    {
    	ofstream fout;
    	fout.open(file.c_str());
    	
    	if(!fout.good())
    	{
    		fout.close();
    		return false;
    	}
    
    	fout << rows << " " << cols << "\n";	
    	print(fout);
    	
    	fout.close();
    	return true;
    }
    
    void Matrix::print(ostream &sout) const
    {
    	for(int i = 0; i < rows; i++)
    	{
    		for(int j = 0; j < cols; j++)
    		{
    			sout << array[i][j] << " ";
    		}
    		sout << "\n";
    	}
    }
    
    int Matrix::getRows() const
    {
    	return rows;
    }
    
    int Matrix::getCols() const
    {
    	return cols;
    }
    
    // Set a value in the matrix by row and column
    void Matrix::set(int row, int col, int value)
    {
    	array[row][col] = value;
    }
    
    // Get a value from the matrix by row and column
    int Matrix::get(int row, int col) const
    {
    	return array[row][col];
    }
    
    // Operator for getting
    const int *Matrix::operator[](int i) const
    {
    	return array[i];
    }
    
    // Operator for setting
    int *Matrix::operator[](int i)
    {
    	return array[i];
    }

I need help with the actual recursion part in the main program. I have no idea what to do. This concept is confusing to me and I'm short on time.

[helios]

I'll give you the function prototype and base case and let you figure out the rest.

int shortest_path(int depth, bool sequence[]){
    if (last_cell())
        return my_value();
    //...
}