NOTE: This problem is a more challenging version of Problem 81.

The minimal path sum in the 5 by 5 matrix below, by starting in any cell in the left column and finishing in any cell in the right column, and only moving up, down, and right, is indicated in red; the sum is equal to 994.

Find the minimal path sum, in matrix.txt (right click and ‘Save Link/Target As…’), a 31K text file containing a 80 by 80 matrix, from the left column to the right column.

Analysis

This is using the same technique that solved problem 18, 67, 81 & 83. We no longer have a fixed starting and ending point so we need to track the starting points to a vector. From there we “bubble” the minimum sums by moving from left to right.

Solution

Runs < 1 second in Perl.

@rows = map { [split /,/] } <DATA>;
$nrows = $#rows;
push @cost, $rows[$_][0] for (0..$nrows);
 
for $x (1..$nrows) {
  for $y (0..$nrows) {
    $cost[$y] = min_n($cost[$y], $cost[$y-1]) + $rows[$y][$x];
  }
  for $y (reverse (0..$nrows-2)) {
    $cost[$y] = min_n($cost[$y], $cost[$y+1] + $rows[$y][$x]);
  }
}
print min_n(@cost);
 
sub min_n { return (sort {$a<=>$b} grep {defined} @_)[0] }
__DATA__
131, 673, 234, 103, 18 
201, 96, 342, 965, 150 
630, 803, 746, 422, 111 
537, 699, 497, 121, 956 
805, 732, 524, 37, 331

Comments

• We’ve included the sample matrix as an example.
• The first line of the program reads the data file, which is appended to the end of the program after the __DATA__ separator, into a two dimensional array named @rows. $nrows is the last index of the array so in this case 4.
• Check here for more information on the min_n function.

In the 5 by 5 matrix below, the minimal path sum from the top left to the bottom right, by only moving to the right and down, is indicated in red and is equal to 2427.

Find the minimal path sum, in matrix.txt (right click and ‘Save Link/Target As…’), a 31K text file containing a 80 by 80 matrix, from the top left to the bottom right by only moving right and down.

Analysis

As with problems 18 & 67 we have a designated starting and ending place. We can use the same technique that solved those problems by starting at the bottom and replacing with minimal sums. See those problems for further information.

Out of bounds (undefined) spaces are ignored from determining a minimum.

Solution

Runs < 1 second in Perl.

my @rows = map { [split /,/] } <DATA>;
my $nrows = $#rows;
 
for (my $i = $nrows; $i >= 0; $i--) {
    for (my $j = $nrows; $j >= 0; $j--) {
        $rows[$i][$j] += min_n($rows[$i+1][$j], $rows[$i][$j+1]);
    }
}
print "Answer to PE81 = $rows[0][0]";
 __DATA__
131, 673, 234, 103, 18 
201, 96, 342, 965, 150 
630, 803, 746, 422, 111 
537, 699, 497, 121, 956 
805, 732, 524, 37, 331

Comments

• We’ve included the sample matrix as an example.
• The first line of the program reads the data file, which is appended to the end of the program after the __DATA__ separator, into a two dimensional array named @rows. $nrows is the last index of the array so in this case 4.
• Check here for more information on the min_n function.

Investigating the number of rectangles in a rectangular grid.
By counting carefully it can be seen that a rectangular grid measuring 3 by 2 contains eighteen rectangles:

Although no rectangular grid exists that contains exactly two million rectangles, find the area of the grid with the nearest solution.

Analysis

To find the sum of the counting numbers from 1 to n is given by the formula n(n+1)/2 or (n²+n)/2). So, for example, the sum of the numbers from 1 to 100 is 100(101)/2 = 5050.

Counting the number of rectangles for an x by y grid is given by the formula: (x²+x) (y²+y) / 4. This is the sum of the counting numbers (1..x) multiplied by the sum of the counting numbers (1..y). In our example for x=3, y=2: (9 + 3) (4 + 2) / 4 = (12 x 6) / 4 = 72/4 = 18. All we need to do is simply find an x and y that yield nearly 2,000,000 rectangles and calculate the area (xy).

Like so many of these problems, more consideration goes into finding and proving the search parameters than solving the actual problem but let’s guess that an upper limit of 100 will work for both x and y and write a brute force program to see if it works:

$min = $max = 2_000_000;
 
for $x (  2 .. 100 ) {
  for $y ( $x .. 100 ) {
    $rec = ($x*$x+$x) * ($y*$y+$y) / 4;
    $diff = abs($max-$rec);
    if ($diff<$min) {
      $min_rec = $rec; $min_x = $x; $min_y = $y; $min=$diff
    }
  }
}
 
print "Area = ",$min_x*$min_y, " ($min_x x $min_y) # Rectangles = $min_recn";

It solves the problem quickly and is fairly extensible. But after looking at it for awhile we see that once a given x is chosen, the y can be derived by solving the quadratic equation:
18 = (x²+x) (y²+y) / 4 or 72 = (x²+x) (y²+y). So when x is known, as 3 for example:
72 = (9 + 3) (y²+y) or 6 = y²+y which solves as y = (-3,2). We are only concerned with the positive component.
Further, the search for x can be terminated once x exceeds y. This is a huge benefit because we have removed any justification required for limits and reduced the search to one loop and that loop does not have to check values that are irrelevant.

Solution

Perl Source: < 1 sec. execution time

my ($max, $x, $min, $rec, $diff, $min_x, $min_y) = (2_000_000, 2, 2_000_000, 0, 0, 0, 0);
 
do {
  $y=int(sqrt( $max*4 / ($x*$x+$x) ));
  $rec = $x*($x+1) * $y*($y+1) / 4;
  $diff = abs($max-$rec);
  if ($diff<$min) { 
    ($min_rec, $min_x, $min_y, $min) = ($rec, $x, $y, $diff);
  }
} until ($y<=$x++);
 
print "Area = ",$min_x*$min_y, " ($min_x x $min_y) # Rectangles = $min_rec  (Target: $max, Delta: $min)  n";

Comments

There are cases where a number of rectangles have many solutions and could yield different areas. One such example is 315 rectangles which yields a=28 (2 x 14) and a=30 (5 x 6).