Update Grid Traveller

Author: simonespa

src/algorithms/dynamic-programming/grid-traveller.test.ts

@@ -0,0 +1,51 @@
+import gridTraveller from './grid-traveller';
+
+const parameters = [
+  { rows: 0, columns: 0, expected: 0 },
+  { rows: 0, columns: 1, expected: 0 },
+  { rows: 1, columns: 0, expected: 0 },
+  { rows: 1, columns: 1, expected: 1 },
+  { rows: 1, columns: 2, expected: 1 },
+  { rows: 2, columns: 1, expected: 1 },
+  { rows: 2, columns: 2, expected: 2 },
+  { rows: 2, columns: 3, expected: 3 },
+  { rows: 3, columns: 2, expected: 3 },
+  { rows: 3, columns: 3, expected: 6 },
+  { rows: 3, columns: 4, expected: 10 },
+  { rows: 4, columns: 3, expected: 10 },
+  { rows: 4, columns: 4, expected: 20 },
+  { rows: 4, columns: 5, expected: 35 },
+  { rows: 5, columns: 4, expected: 35 },
+  { rows: 5, columns: 5, expected: 70 },
+  { rows: 5, columns: 6, expected: 126 },
+  { rows: 6, columns: 5, expected: 126 },
+  { rows: 6, columns: 6, expected: 252 },
+  { rows: 6, columns: 7, expected: 462 },
+  { rows: 7, columns: 6, expected: 462 },
+  { rows: 7, columns: 7, expected: 924 },
+  { rows: 7, columns: 8, expected: 1716 },
+  { rows: 8, columns: 7, expected: 1716 },
+  { rows: 8, columns: 8, expected: 3432 },
+  { rows: 8, columns: 9, expected: 6435 },
+  { rows: 9, columns: 8, expected: 6435 },
+  { rows: 9, columns: 9, expected: 12870 },
+  { rows: 9, columns: 10, expected: 24310 },
+  { rows: 10, columns: 9, expected: 24310 },
+  { rows: 10, columns: 10, expected: 48620 },
+  { rows: 20, columns: 20, expected: 35345263800 },
+  { rows: 30, columns: 30, expected: 30067266499541040 },
+  { rows: 40, columns: 40, expected: 2.7217014869199036e+22 },
+  { rows: 50, columns: 50, expected: 2.5477612258980867e+28 },
+  { rows: 60, columns: 60, expected: 2.4356699707654625e+34 },
+  { rows: 70, columns: 70, expected: 2.362398517571512e+40 },
+  { rows: 80, columns: 80, expected: 2.3156006494021195e+46 },
+  { rows: 90, columns: 90, expected: 2.288017424736007e+52 },
+  { rows: 100, columns: 100, expected: 2.2750883079422938e+58 },
+];
+
+test.each(parameters)(
+  'gridTraveller($rows, $columns) = $expected',
+  ({ rows, columns, expected }) => {
+    expect(gridTraveller(rows, columns)).toEqual(expected);
+  }
+);

src/algorithms/dynamic-programming/grid-traveller.ts

@@ -1,93 +1,46 @@
 /**
- * - Time complexity: O(2^n+m)
- * - Space complexity: O(n+m)
  *
- * where "n" is the number of rows and "m" the number of columns.
- *
- * @param rows the number of rows of the grid.
- * @param columns the number of columns of the grid.
- */
-function bruteForceGridTraveller(rows: number, columns: number): number {
-  if (rows === 0 || columns === 0) return 0;
-  if (rows === 1 && columns === 1) return 1;
-
-  return bruteForceGridTraveller(rows - 1, columns) + bruteForceGridTraveller(rows, columns - 1);
-}
-
-/**
- * - Time complexity: O(n+m)
- * - Space complexity: O(n+m)
- *
- * where "n" is the number of rows and "m" the number of columns.
- *
- * @param rows the number of rows of the grid.
- * @param columns the number of columns of the grid.
- * @param buffer buffer object used for memoisation.
+ * @param rows the number of rows of the grid
+ * @param columns the number of columns of the grid
+ * @param buffer the buffer used for memoisation
+ * @returns how many ways there are to travel on a n by m grid
  */
-function memoisedGridTraveller(
-  rows: number,
-  columns: number,
-  buffer: { [key: string]: number } = {}
-): number {
-  const key = `${rows}-${columns}`;
+export default function gridTraveller(rows: number, columns: number, buffer: object = {}): number {
+  const key = getKey(rows, columns);
   if (key in buffer) return buffer[key];
   if (rows <= 0 || columns <= 0) return 0;
-  if (rows === 1 && columns === 1) return 1;
+  if (rows === 1 || columns === 1) return 1;
 
   buffer[key] =
-    memoisedGridTraveller(rows - 1, columns, buffer) +
-    memoisedGridTraveller(rows, columns - 1, buffer);
+    // travels down in the grid (decrement the row)
+    gridTraveller(rows - 1, columns, buffer) +
+    // travels right in the grid (decrement the column)
+    gridTraveller(rows, columns - 1, buffer);
+
   return buffer[key];
 }
 
 /**
+ * Return a key built out of the input parameters.
+ *
+ * This snippet creates a key to de-dupe the entries in the buffer.
+ *
+ * The key uses a separator to prevent collisions. Without separator
+ * we may have this situation "789" where it is unclear whether
+ * n = 7 and m = 89 or n = 78 and m = 9
+ *
+ * Given (n = 7, m = 3) and (n = 3, m = 7) have the same result,
+ * the ksy is also normalised with the first element before the
+ * separator being less or equal than the second element.
  *
+ * @param rows the number of rows of the grid
+ * @param columns the number of columns of the grid
+ * @returns a key to be used in the buffer object
  */
-function dedupedGridTraveller(
-  rows: number,
-  columns: number,
-  buffer: { [key: string]: number } = {}
-): number {
-  let key = `${rows}-${columns}`;
+function getKey(rows: number, columns: number) {
   if (columns < rows) {
-    key = `${columns}-${rows}`;
-  }
-  if (key in buffer) return buffer[key];
-  if (rows <= 0 || columns <= 0) return 0;
-  if (rows === 1 && columns === 1) return 1;
-
-  buffer[key] =
-    dedupedGridTraveller(rows - 1, columns, buffer) +
-    dedupedGridTraveller(rows, columns - 1, buffer);
-  return buffer[key];
-}
-
-/**
- * @param rows the number of rows of the grid.
- * @param columns the number of columns of the grid.
- * @param memoised true to optimise the recursive function by caching the intermediate responses.
- * @param deduped true to optimise the recursive function by removing duplicate branch in the tree.
- */
-export interface GridTravellerParameters {
-  rows: number;
-  columns: number;
-  memoised?: boolean;
-  deduped?: boolean;
-}
-
-/**
- * Returns the number of path reachable from the top left corner to the bottom right one in a N x M grid.
- */
-export default function gridTraveller(parameters: GridTravellerParameters): number {
-  const { rows, columns, memoised, deduped } = parameters;
-
-  if (deduped) {
-    return dedupedGridTraveller(rows, columns);
-  }
-
-  if (memoised) {
-    return memoisedGridTraveller(rows, columns);
+    return `${columns}-${rows}`;
   }
 
-  return bruteForceGridTraveller(rows, columns);
+  return `${rows}-${columns}`;
 }