Algunos de los problemas:

• Después de la llamada inicial de dfs , su código siempre devuelve el resultado. Esto significa que asume que si la primera letra coincide, la palabra completa debe coincidir comenzando en esa celda. Pero esto no es cierto. Es posible que no encuentre una coincidencia allí, mientras que puede haber otros lugares en la cuadrícula con esa primera letra que proporcionen una coincidencia de palabra completa. Entonces, esta declaración de return debe ser condicional (solo cuando hay éxito).

• La matriz a la que hace referencia res solo crece. Nunca se encoge. Tenga en cuenta que solo hay una matriz res , a la que hacen referencia todas las variables res que viven en los contextos de ejecución de dfs . Por lo tanto, todas las coincidencias parciales (que eventualmente no conducen a una coincidencia completa) se recopilan y se concatenan una tras otra. No se le aplica retroceso.

  Me parece más elegante comenzar a construir una matriz solo cuando se ha hecho coincidir la palabra completa, y luego completar una matriz mientras salgo de las llamadas recursivas (en lugar de hacer esto mientras se profundiza la recursividad).

• Las llamadas recursivas de dfs ignoran por completo los valores que devuelven esas llamadas, por lo que no se hace distinción entre falla y éxito. Debería verificar el resultado de la primera llamada recursiva y, si fue exitosa, la segunda ni siquiera debería realizarse.

• No hay problema, pero la condición en if (grid[i][j] == word[wordIndex]) { siempre será verdadera, dado que ya probó la condición opuesta en la declaración if anterior.

Aquí hay una corrección a su código, también implementando la idea que expresé en el segundo punto, es decir, solo llenando una matriz cuando ya se sabe que fue un éxito:

 // No res argument. res will be populated "inside-out" via the return value function find_word_location (grid, word) { const dfs = (i, j, wordIndex) => { if (wordIndex == word.length) return []; // Start a solution with this res if ( i > grid.length - 1 || j > grid[0].length - 1 || grid[i][j] !== word[wordIndex] ) return; grid[i][j] = "#"; // Use the returned value // and apply short-circuit to avoid useless second call const res = dfs(i + 1, j, wordIndex + 1) || dfs(i, j + 1, wordIndex + 1); grid[i][j] = word[wordIndex]; if (res) res.unshift([i, j]); // Extend the path we got from recursion return res; }; for (let i = 0; i < grid.length; i++) { for (let j = 0; j < grid[0].length; j++) { if (grid[i][j] == word[0]) { let result = dfs(i, j, 0, []); if (result) return result; // conditionally } } } return []; } var grid = [ ['c', 'c', 'x', 't', 'i', 'b'], ['c', 'c', 'a', 't', 'n', 'i'], ['a', 'c', 'n', 'n', 't', 't'], ['t', 'c', 's', 'i', 'p', 't'], ['a', 'o', 'o', 'o', 'a', 'a'], ['o', 'a', 'a', 'a', 'o', 'o'], ['k', 'a', 'i', 'c', 'k', 'i'], ]; var word = "catnip"; var result = find_word_location(grid, word); console.log(result);

Este enfoque no entrega el resultado a la llamada recursiva.

La función toma grid , la word o la parte sobrante de la palabra y los índices reales, que tienen cero como valor predeterminado.

En el interior, la condición de salida viene primero al verificar los límites.

Luego sigue una verificación del carácter buscado.

Dentro de él, verifique con la nueva longitud de palabra, sin carácter real y si es una cadena vacía, devuelve los índices.

El resto es casi idéntico sin la parte para verificar los índices encontrados y si son adyacentes al elemento real.

Aproximadamente, obtenga subíndices, verifique si hay índices y devuelva el resultado con índices reales (coincidencia de letras) o solo el resto.

 const findWord = (grid, word, i = 0, j = 0) => { const isAdjacent = (x, y) => x === i && y === j + 1 || x === i + 1 && y === j; let sub; if (i + 1 === grid.length || j + 1 === grid[i].length) return []; if (grid[i][j] === word[0]) { const w = word.slice(1); if (!w.length) return [[i, j]]; sub = findWord(grid, w, i + 1, j); if (sub.length && isAdjacent(...sub[0])) return [[i, j], ...sub]; sub = findWord(grid, w, i, j + 1); if (sub.length && isAdjacent(...sub[0])) return [[i, j], ...sub]; } sub = findWord(grid, word, i + 1, j); if (sub.length) return sub; sub = findWord(grid, word, i, j + 1); if (sub.length) return sub; return []; }, grid = [['c', 'c', 'x', 't', 'i', 'b'], ['c', 'c', 'a', 't', 'n', 'i'], ['a', 'c', 'n', 'n', 't', 't'], ['t', 'c', 's', 'i', 'p', 't'], ['a', 'o', 'o', 'o', 'a', 'a'], ['o', 'a', 'a', 'a', 'o', 'o'], ['k', 'a', 'i', 'c', 'k', 'i']], word = "catnip", result = findWord(grid, word); console.log(result.map(p => p.join('-')));

 .as-console-wrapper { max-height: 100% !important; top: 0; }