Number of ways from top left to bottom right of an array - arrays

Question

I was playing around with the following problem:
Given a 2-d array find all the possible ways we can move from the top
left cell [0][0] to the bottom right cell [N-1][N-1] given that we
can only move either downward or rightward?
I defined the following:
For an array such as [ [ 1 ] ] there is only 1 way to go from the start cell to the destination cell. We are already there.
Otherwise it the total number of ways is the total number of ways we go from the cell to the right to the destination plus 1 (there is 1 way to go from current cell to the next cell) plus the total number of ways we go from the cell bellow to the destination plus 1 (there is 1 way to go from current cell to the bellow cell)
So for an array such as:
[
[1, 2]
[3, 4]
]
the answer would be 4 (1->2, 2->4, 1->3, 3->4).
For an array such as:
[
[1, 2, 3],
[3, 4, 5],
]
The answer should be 8. 4 comes from the subarray to the right + 1 to go for (1)->(2) plus 1->3 3->4 4->5 total 3.
So 5 + 3 = 7.
The following code seems to me correct but I am messing something up and I get the wrong result.
my $array = [
[1, 2, 3],
[3, 4, 5],
];
sub number_of_ways {
my ( $input, $source_row, $source_col, $dest_row, $dest_col ) = #_;
if ( $source_row == $dest_row && $source_col == $dest_col ) {
return 1;
}
if ( $source_row >= scalar #$input) {
return 0;
}
if ( $source_col >= scalar #{$input->[$source_row]} ) {
return 0;
}
my $ways_down = number_of_ways($input, $source_row + 1, $source_col, $dest_row, $dest_col);
my $ways_right = number_of_ways($input, $source_row, $source_col + 1, $dest_row, $dest_col);
my $total = $ways_right + 1 if ( $ways_right );
$total += $ways_down + 1 if ( $ways_down );
return $total;
}
print "Number of ways: " . number_of_ways($array, 0, 0, 1, 2). "\n";
This give me 11.
Is the logic wrong?
Update:
With the help of #m69 I found the problem.
In recursion is a bad idea to do the iteration if we already can check if it is going to fail. In this case, even after changing the code after the comments of #m69 it failed because there is no distinction between 0 because we are in an subarray with 1 element (source and destination are the same) or outside of the array.
The following code seems to be correct.
sub number_of_ways {
my ( $input, $source_row, $source_col, $dest_row, $dest_col ) = #_;
if ( $source_row == $dest_row && $source_col == $dest_col ) {
return 0;
}
my $total = 0;
if ( $source_row < #$input - 1) {
my $ways_down = number_of_ways($input, $source_row + 1, $source_col, $dest_row, $dest_col);
$total += $ways_down + 1;
}
if ( $source_col < #{$input->[$source_row]} - 1 ) {
my $ways_right = number_of_ways($input, $source_row, $source_col + 1, $dest_row, $dest_col);
$total += $ways_right + 1;
}
return $total;
}
print "Number of ways: " . number_of_ways($array, 0, 0, 1, 2). "\n";

Answer 1

Your algorithm uses this recursion:
0 1 2 0---1 2 0
= + |
3 4 5 4 5 3 4 5
which then goes on to:
1 2 1---2 1
= + | AND
4 5 5 4 5 3 4 5 = 3---4 5
and then:
2 2
= | AND AND
5 5 4 5 = 4---5 4 5 = 4---5
and finally:
5 AND 5 AND 5
In itself, this is a useful way of recursing in the 3x2 grid, but the way you then add the steps is problematic; e.g. after receiving 4 as the result of the recursion with the 2x2 grid [[1,2][4,5]], you add 1 to it because it takes 1 step to go from position 0 to the 2x2 grid. However, there are two paths through the 2x2 grid, so you should add the 1 step twice. Knowing how many paths there were through the 2x2 grid requires calculating the Taxicab distance through it, and then dividing the number of steps by this distance. You'll see that this results in a lot of unnecessary calculations, because the number of steps in each complete path is always the same. So it's much easier to just find the number of paths, and then multiply them by the number of steps per path.
You can use the recursion you have to find the number of paths; from the breakdown into steps of the recursion above you'll see that you end up with the 1x1 grid [5] three times. This is because there are three paths that lead to position 5. If you simply count how many times you recurse with that 1x1 grid), you know the number of paths. To know the number of steps you can then multiply by (width - 1) + (height - 1) which is the number of steps in each path.
The disadvantage of simply incrementing a variable outside the scope of the recursion is that you cannot easily turn it into a dynamic programming solution, because you have to go through with every recursion to the end, to count how many times you get to the bottom-right corner. So it's probably better to pass the results back up the recursion chain.
If you return 1 when the input is a 1x1 grid, and the sum of the right and down result in a larger grid (without adding anything to it), this also gives you the total number of paths. Then you can memoize the results by storing that a 2x1 and 1x2 grid return 1, a 2x2 grid returns 2, a 3x2 and 2x3 grid returns 3, a 3x3 grid returns 6, and use these stored values instead of recursing over grids with the same size again.
You'll see that the number of paths through any size grid is given by this table:
1 1 1 1 1 ...
1 2 3 4 5
1 3 6 10 15
1 4 10 20 35
1 5 15 35 70
where each value is the sum of the values above and to the left of it, which also points to a simple non-recursive way to calculate the number of paths (or steps) through any size grid.
This code snippet in JavaScript uses the recursion method from your code to count the number of paths, and then calculates the total number of steps:
function count_paths(grid, x, y) {
x = x || 0; y = y || 0;
var height = grid.length - y;
var width = grid[0].length - x;
if (width == 0 || height == 0) return 0;
if (width == 1 && height == 1) return 1;
return count_paths(grid, x + 1, y) + count_paths(grid, x, y + 1);
}
var grid = [[0,1,2,3],[4,5,6,7],[8,9,10,11],[12,13,14,15]];
var paths = count_paths(grid);
var steps = paths * (grid.length - 1 + grid[0].length - 1);
document.write("paths: " + paths + "<br>steps: " + steps);
To integrate the calculation of the total number of steps into the recursion, you'd have to return the number of paths and the number of steps, so that you can multiply the step it takes to go right or down by the number of paths that that step leads to:
function count_steps(grid, x, y) {
x = x || 0; y = y || 0;
var height = grid.length - y;
var width = grid[0].length - x;
if (width == 0 || height == 0) return {paths: 0, steps: 0};
if (width == 1 && height == 1) return {paths: 1, steps: 0};
var right = count_steps(grid, x + 1, y);
var down = count_steps(grid, x, y + 1);
var paths = right.paths + down.paths;
var steps = right.steps + down.steps + paths;
return {paths: paths, steps: steps};
}
var grid = [[0,1,2,3],[4,5,6,7],[8,9,10,11],[12,13,14,15]];
var count = count_steps(grid);
document.write("paths: " + count.paths + "<br>steps: " + count.steps);