Cat and Mouse II minified

Author: hasibulislam999

Game Theory/1728_cat-and-mouse-ii.js

@@ -11,100 +11,84 @@
  * @param {number} mouseJump
  * @return {boolean}
  */
-function canMouseWin(grid, catJump, mouseJump) {
-  const dirs = [
-    [1, 0],
-    [-1, 0],
-    [0, 1],
-    [0, -1],
-  ];
-  const m = grid.length;
-  const n = grid[0].length;
-  let mouse_pos = null;
-  let cat_pos = null;
-  let available = 0; // available steps for mouse and cat
+var canMouseWin = function (A, maxC, maxM) {
+  let n = A.length,
+    m = A[0].length,
+    seen = {},
+    pos = [
+      [0, 1],
+      [0, -1],
+      [1, 0],
+      [-1, 0],
+    ],
+    xM,
+    yM,
+    xC,
+    yC,
+    xF,
+    yF;
+  for (let i = 0; i < n; i++)
+    for (let j = 0; j < m; j++)
+      if (A[i][j] === "M") [xM, yM] = [i, j];
+      else if (A[i][j] === "C") [xC, yC] = [i, j];
+      else if (A[i][j] === "F") [xF, yF] = [i, j];
 
-  // Search the start pos of mouse and cat
-  for (let i = 0; i < m; i++) {
-    for (let j = 0; j < n; j++) {
-      if (grid[i][j] !== "#") {
-        available++;
-      }
-      if (grid[i][j] === "M") {
-        mouse_pos = [i, j];
-      } else if (grid[i][j] === "C") {
-        cat_pos = [i, j];
-      }
-    }
-  }
+  let invalid = ([x, y]) =>
+    x < 0 || x >= n || y < 0 || y >= m ? true : A[x][y] === "#";
 
-  const dp = function (turn, mouse_pos, cat_pos) {
-    // if (turn === m * n * 2) {
-    // We already search the whole grid (9372 ms 74.3 MB)
-    if (turn === available * 2) {
-      // We already search the whole touchable grid (5200 ms 57.5 MB)
-      return false;
-    }
-    if (turn % 2 === 0) {
-      // Mouse
-      const [i, j] = mouse_pos;
-      for (let [di, dj] of dirs) {
-        for (let jump = 0; jump <= mouseJump; jump++) {
-          // Note that we want to do range(mouseJump + 1) instead of range(1, mouseJump + 1)
-          // considering the case that we can stay at the same position for next turn.
-          const new_i = i + di * jump;
-          const new_j = j + dj * jump;
+  //returns whether the current player ( determined by level -odd/even) can win the game while on the current state
+  let recursion = ([[xM, yM], [xC, yC]], level) => {
+    let whoPlays = Boolean(level % 2),
+      state = [
+        [
+          [xM, yM],
+          [xC, yC],
+        ],
+        level,
+      ].toString(),
+      maxAllowable = whoPlays ? maxC : maxM;
+    if (seen[state] === undefined) {
+      //memoization
+      //end states
+      if ((xC === xF && yC === yF) || (xC === xM && yC === yM) || level >= 70)
+        // level>=70 makes this pass
+        return (seen[state] = whoPlays);
+      if (xM === xF && yM === yF) return (seen[state] = !whoPlays);
+      //try staying still first
+      if (
+        recursion(
+          [
+            [xM, yM],
+            [xC, yC],
+          ],
+          level + 1
+        ) === false
+      )
+        return (seen[state] = true);
+      //then try moving
+      for (let [dx, dy] of pos)
+        for (let k = 1; k <= maxAllowable; k++) {
+          let newState = whoPlays
+            ? [xC + dx * k, yC + dy * k]
+            : [xM + dx * k, yM + dy * k];
+          if (invalid(newState) || seen[state]) break;
           if (
-            0 <= new_i &&
-            new_i < m &&
-            0 <= new_j &&
-            new_j < n &&
-            grid[new_i][new_j] !== "#"
-          ) {
-            // Valid pos
-            if (
-              dp(turn + 1, [new_i, new_j], cat_pos) ||
-              grid[new_i][new_j] === "F"
-            ) {
-              return true;
-            }
-          } else {
-            // Stop extending the jump since we cannot go further
-            break;
-          }
+            recursion(
+              whoPlays ? [[xM, yM], newState] : [newState, [xC, yC]],
+              level + 1
+            ) === false
+          )
+            return (seen[state] = true);
         }
-      }
-      return false;
-    } else {
-      // Cat
-      const [i, j] = cat_pos;
-      for (let [di, dj] of dirs) {
-        for (let jump = 0; jump <= catJump; jump++) {
-          const new_i = i + di * jump;
-          const new_j = j + dj * jump;
-          if (
-            0 <= new_i &&
-            new_i < m &&
-            0 <= new_j &&
-            new_j < n &&
-            grid[new_i][new_j] !== "#"
-          ) {
-            if (
-              !dp(turn + 1, mouse_pos, [new_i, new_j]) ||
-              (new_i === mouse_pos[0] && new_j === mouse_pos[1]) ||
-              grid[new_i][new_j] === "F"
-            ) {
-              // This condition will also handle the case that the cat cannot jump through the mouse
-              return false;
-            }
-          } else {
-            break;
-          }
-        }
-      }
-      return true;
+      seen[state] = false;
     }
+    return seen[state];
   };
-
-  return dp(0, mouse_pos, cat_pos);
-}
+  return recursion(
+    [
+      [xM, yM],
+      [xC, yC],
+    ],
+    0
+  );
+};