The diagram below shows a $4\times4$ rectangular array of points, each of which is $1$ unit away from its nearest neighbors.
[asy] unitsize(0.25inch); defaultpen(linewidth(0.7));  int i, j; for(i = 0; i < 4; ++i) 	for(j = 0; j < 4; ++j) 		dot(((real)i, (real)j)); [/asy]
Define a growing path to be a sequence of distinct points of the array with the property that the distance between consecutive points of the sequence is strictly increasing. Let $m$ be the maximum possible number of points in a growing path, and let $r$ be the number of growing paths consisting of exactly $m$ points. Find $mr$.

We label our points using coordinates $0 \le x,y \le 3$, with the bottom-left point being $(0,0)$. By the Pythagorean Theorem, the distance between two points is $\sqrt{d_x^2 + d_y^2}$ where $0 \le d_x, d_y \le 3$; these yield the possible distances (in decreasing order)\[\sqrt{18},\ \sqrt{13},\ \sqrt{10},\ \sqrt{9},\ \sqrt{8},\ \sqrt{5},\ \sqrt{4},\ \sqrt{2},\ \sqrt{1}\]As these define $9$ lengths, so the maximum value of $m$ is $10$. For now, we assume that $m = 10$ is achievable. Because it is difficult to immediately impose restrictions on a path with increasing distances, we consider the paths in shrinking fashion. Note that the shrinking paths and growing paths are equivalent, but there are restrictions upon the locations of the first edges of the former.
The $\sqrt{18}$ length is only possible for one of the long diagonals, so our path must start with one of the $4$ corners of the grid. Without loss of generality (since the grid is rotationally symmetric), we let the vertex be $(0,0)$ and the endpoint be $(3,3)$.
[asy] unitsize(0.25inch); defaultpen(linewidth(0.7)); dotfactor = 4; pen s = linewidth(4);  int i, j; for(i = 0; i < 4; ++i) 	for(j = 0; j < 4; ++j) 		dot(((real)i, (real)j)); dot((0,0)^^(3,3),s); draw((0,0)--(3,3));  [/asy]
The $\sqrt{13}$ length can now only go to $2$ points; due to reflectional symmetry about the main diagonal, we may WLOG let the next endpoint be $(1,0)$.
[asy] unitsize(0.25inch); defaultpen(linewidth(0.7)); dotfactor = 4; pen s = linewidth(4); pen c = rgb(0.5,0.5,0.5); int i, j; for(i = 0; i < 4; ++i) 	for(j = 0; j < 4; ++j) 		dot(((real)i, (real)j)); dot((0,0)^^(3,3)^^(1,0),s); draw((0,0)--(3,3),c); draw((3,3)--(1,0));  [/asy]
From $(1,0)$, there are two possible ways to move $\sqrt{10}$ away, either to $(0,3)$ or $(2,3)$. However, from $(0,3)$, there is no way to move $\sqrt{9}$ away, so we discard it as a possibility.
From $(2,3)$, the lengths of $\sqrt{8},\ \sqrt{5},\ \sqrt{4},\ \sqrt{2}$ fortunately are all determined, with the endpoint sequence being $(2,3)-(2,0)-(0,2)-(2,1)-(0,1)-(1,2)$.
[asy] unitsize(0.25inch); defaultpen(linewidth(0.7)); dotfactor = 4; pen s = linewidth(4); pen c = rgb(0.5,0.5,0.5); int i, j; for(i = 0; i < 4; ++i) 	for(j = 0; j < 4; ++j) 		dot(((real)i, (real)j)); dot((0,0)^^(3,3)^^(1,0)^^(2,3)^^(2,0)^^(0,2)^^(2,1)^^(0,1)^^(1,2),s); draw((0,0)--(3,3)--(1,0)--(2,3)--(2,0)--(0,2)--(2,1)--(0,1)--(1,2)); [/asy]
From $(1,2)$, there are $3$ possible lengths of $\sqrt{1}$ (to either $(1,1),(2,2),(1,3)$). Thus, the number of paths is $r = 4 \cdot 2 \cdot 3 = 24$, and the answer is $mr = 10 \cdot 24 = \boxed{240}$.
240
Level 5
Counting & Probability
Problem: The diagram below shows a $4\times4$ rectangular array of points, each of which is $1$ unit away from its nearest neighbors.
[asy] unitsize(0.25inch); defaultpen(linewidth(0.7));  int i, j; for(i = 0; i < 4; ++i) 	for(j = 0; j < 4; ++j) 		dot(((real)i, (real)j)); [/asy]
Define a growing path to be a sequence of distinct points of the array with the property that the distance between consecutive points of the sequence is strictly increasing. Let $m$ be the maximum possible number of points in a growing path, and let $r$ be the number of growing paths consisting of exactly $m$ points. Find $mr$.

Solution:<|START_OF_LATENT|><|PRIOR_PREFIX|>To determine the maximum number of points in a growing path, we first analyze the distances between points in the $4 \times 4$ array. The points can be represented as coordinates in a Cartesian plane, where each point is at integer coordinates from $(0,0)$ to $(3,3)$. 

The distance between any two points $(x_1, y_1)$ and $(x_2, y_2)$ is given by the Euclidean distance formula: 

d = sqrt((x2 - x1)² + (y2 - y1)²).

The possible distances between points in the array range from 1 (between adjacent points) to the maximum distance, which is the diagonal distance between opposite corners, calculated as:

d_max = sqrt((3 - 0)² + (3 - 0)²) = sqrt(18) = 3√2.

Next, we consider the requirement that the distances between consecutive points in a growing path must be strictly increasing. This means that if we start with a distance of 1, the next distance must be greater than 1, and so on. 

The distinct distances available in the array are: 
1 (adjacent points), 
sqrt(2) (diagonal points), 
2 (two units apart horizontally or vertically), 
sqrt(5) (one unit horizontally and two units vertically), 
sqrt(8) (two units diagonally), 
sqrt(10) (one unit horizontally and three units vertically), 
sqrt(13) (two units horizontally and one unit vertically), 
sqrt(18) (three units diagonally), 
3 (three units apart horizontally or vertically), 
and 3√2 (the maximum diagonal distance).

To maximize the number of points in a growing path, we need to select distances that can be achieved by distinct pairs of points in the array. The maximum number of distinct distances that can be used while maintaining the strictly increasing condition is 10, corresponding to the distances listed above.

Next, we need to count the number of distinct growing paths that can be formed using these distances. Each path must consist of distinct points, and the arrangement of points must allow for the distances to be strictly increasing. 

By systematically exploring combinations of points and ensuring that the distance condition is met, we find that there are 240 distinct growing paths that can be formed with the maximum number of points.

Thus, we define m as the maximum number of points in a growing path, which is 10, and r as the number of such paths, which is 24. The final calculation for mr is:

mr = m * r = 10 * 24 = 240.<|END_OF_LATENT|> The final answer is $240$.