Question

I found this question on a programming forum:

A table composed of N*M cells,each having a certain quantity of apples, is given. you start from the upper-left corner. At each step you can go down or right one cell.Design an algorithm to find the maximum number of apples you can collect ,if you are moving from upper-left corner to bottom-right corner.

I have thought of three different complexities[in terms of time & space]:

Approach 1[quickest]:

for(j=1,i=0;j<column;j++)
    apple[i][j]=apple[i][j-1]+apple[i][j];
for(i=1,j=0;i<row;i++)
    apple[i][j]=apple[i-1][j]+apple[i][j];

for(i=1;i<row;i++)
{
    for(j=1;j<column;j++)
    {
        if(apple[i][j-1]>=apple[i-1][j])
            apple[i][j]=apple[i][j]+apple[i][j-1];
        else
            apple[i][j]=apple[i][j]+apple[i-1][j];
    }
}
printf("\n maximum apple u can pick=%d",apple[row-1][column-1]);    

Approach 2:

result is the temporary array having all slots initially 0.

int getMax(int i, int j)
{
    if( (i<ROW) && (j<COL) )
    {
        if( result[i][j] != 0 )
            return result[i][j];
        else
        {
            int right = getMax(i, j+1);
            int down = getMax(i+1, j);

            result[i][j] = ( (right>down) ? right : down )+apples[i][j];
            return result[i][j];
        }
    }
    else
        return 0;
}

Approach 3[least space used]:

It doesn’t use any temporary array.

int getMax(int i, int j)
{
    if( (i<M) && (j<N) )
    {
            int right = getMax(i, j+1);
            int down = getMax(i+1, j);
            return apples[i][j]+(right>down?right:down);
    }
    else
        return 0;
}

I want to know which is the best way to solve this problem?

Answer 1

There’s little difference between approaches 1 and 2, approach 1 is probably a wee bit better since it doesn’t need the stack for the recursion that approach 2 uses since that goes backwards.

Approach 3 has exponential time complexity, thus it is much worse than the other two which have complexitx O(rows*columns).

You can make a variant of approach 1 that proceeds along a diagonal to use only O(max{rows,columns}) additional space.