Primera publicación momento pensé que iba a tratar a esta población.
He investigado durante horas y yo no puede parecer a encontrar un ejemplo lo suficientemente cerca de obtener ideas de. No me importa lo que las respuestas están en idioma pero preferirían Java, C / C ++ o pseudocódigo.
Busco para encontrar caminos consecutivos de longitud n en una cuadrícula.
He encontrado una solución recursiva que creo que estaba limpio y siempre trabajado, pero el tiempo de ejecución era pobre si el número de carriles es demasiado grande. Me di cuenta de que podría ponerlo en práctica de manera iterativa, pero quiero encontrar una solución recursiva primero.
No me importa lo que las respuestas están en idioma pero preferirían Java, C / C ++.
El problema es esto- para un String [] y una longitud de trayectoria int cuántos caminos hay de esa longitud.
{ "ABC", "CBZ", "CZC", "BZZ", "ZAA"} de longitud 3
Esta es la tercera y séptima ruta desde abajo.
A B C A . C A B . A . . A . . A . . . . .
. . . . B . C . . C B . . B . . B . . . .
. . . . . . . . . . . . C . . . . C C . .
. . . . . . . . . . . . . . . . . . B . .
. . . . . . . . . . . . . . . . . . . A .
(spaces are for clarity only)
la vuelta de 7 posibles caminos de longitud 3 (ABC)
Esta fue la solución recursiva originales
public class SimpleRecursive {
private int ofLength;
private int paths = 0;
private String[] grid;
public int count(String[] grid, int ofLength) {
this.grid = grid;
this.ofLength = ofLength;
paths = 0;
long startTime = System.currentTimeMillis();
for (int j = 0; j < grid.length; j++) {
for (int index = grid[j].indexOf('A'); index >= 0; index = grid[j].indexOf('A', index + 1)) {
recursiveFind(1, index, j);
}
}
System.out.println(System.currentTimeMillis() - startTime);
return paths;
}
private void recursiveFind(int layer, int x, int y) {
if (paths >= 1_000_000_000) {
}
else if (layer == ofLength) {
paths++;
}
else {
int xBound = grid[0].length();
int yBound = grid.length;
for (int dx = -1; dx <= 1; ++dx) {
for (int dy = -1; dy <= 1; ++dy) {
if (dx != 0 || dy != 0) {
if ((x + dx < xBound && y + dy < yBound) && (x + dx >= 0 && y + dy >= 0)) {
if (grid[y].charAt(x) + 1 == grid[y + dy].charAt(x + dx)) {
recursiveFind(layer + 1, x + dx, y + dy);
}
}
}
}
}
}
}
}
Esto era muy lento debido a que cada nueva carta podría escindir 8 recurrencias por lo que los cohetes de complejidad.
Decidí usar memoization para mejorar el rendimiento.
Esto es lo que ocurrió.
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class AlphabetCount {
private int ofLength;
private int paths = 0;
private String[] grid;
// This was an optimization that helped a little. It would store possible next paths
// private HashMap<Integer, ArrayList<int[]>> memoStack = new HashMap<Integer, ArrayList<int[]>>();
//hashmap of indices that are part of a complete path(memoization saves)
private HashMap<Integer, int[]> completedPath = new HashMap<Integer, int[]>();
//entry point
public int count(String[] grid, int ofLength) {
this.grid = grid;
//Since i find the starting point ('A') by brute force then i just need the next n-1 letters
this.ofLength = ofLength - 1;
//variable to hold number of completed runs
paths = 0;
//holds the path that was taken to get to current place. determined that i dont really need to memoize 'Z' hence ofLength -1 again
List<int[]> fullPath = new ArrayList<int[]>(ofLength - 1);
//just a timer to compare optimizations
long startTime = System.currentTimeMillis();
//this just loops around finding the next 'A'
for (int j = 0; j < grid.length; j++) {
for (int index = grid[j].indexOf('A'); index >= 0; index = grid[j].indexOf('A', index + 1)) {
//into recursive function. fullPath needs to be kept in this call so that it maintains state relevant to call stack? also the 0 here is technically 'B' because we already found 'A'
recursiveFind(fullPath, 0, index, j);
}
}
System.out.println(System.currentTimeMillis() - startTime);
return paths;
}
private void recursiveFind(List<int[]> fullPath, int layer, int x, int y) {
//hashing key. mimics strings tohash. should not have any duplicates to my knowledge
int key = 31 * (x) + 62 * (y) + 93 * layer;
//if there is more than 1000000000 paths then just stop counting and tell me its over 1000000000
if (paths >= 1_000_000_000) {
//this if statement never returns true unfortunately.. this is the optimization that would actually help me.
} else if (completedPath.containsKey(key)) {
paths++;
for (int i = 0; i < fullPath.size() - 1; i++) {
int mkey = 31 * fullPath.get(i)[0] + 62 * fullPath.get(i)[1] + 93 * (i);
if (!completedPath.containsKey(mkey)) {
completedPath.put(mkey, fullPath.get(i));
}
}
}
//if we have a full run then save the path we took into the memoization hashmap and then increase paths
else if (layer == ofLength) {
for (int i = 0; i < fullPath.size() - 1; i++) {
int mkey = 31 * fullPath.get(i)[0] + 62 * fullPath.get(i)[1] + 93 * (i);
if (!completedPath.containsKey(mkey)) {
completedPath.put(mkey, fullPath.get(i));
}
}
paths++;
}
//everything with memoStack is an optimization that i used that increased performance marginally.
// else if (memoStack.containsKey(key)) {
// for (int[] path : memoStack.get(key)) {
// recursiveFind(fullPath,layer + 1, path[0], path[1]);
// }
// }
else {
int xBound = grid[0].length();
int yBound = grid.length;
// ArrayList<int[]> newPaths = new ArrayList<int[]>();
int[] pair = new int[2];
//this loop checks indices adjacent in all 8 directions ignoring index you are in then checks to see if you are out of bounds then checks to see if one of those directions has the next character
for (int dx = -1; dx <= 1; ++dx) {
for (int dy = -1; dy <= 1; ++dy) {
if (dx != 0 || dy != 0) {
if ((x + dx < xBound && y + dy < yBound) && (x + dx >= 0 && y + dy >= 0)) {
if (grid[y].charAt(x) + 1 == grid[y + dy].charAt(x + dx)) {
pair[0] = x + dx;
pair[1] = y + dy;
// newPaths.add(pair.clone());
//not sure about this... i wanted to save space by not allocating everything but i needed fullPath to only have the path up to the current call
fullPath.subList(layer, fullPath.size()).clear();
//i reuse the int[] pair so it needs to be cloned
fullPath.add(pair.clone());
//recursive call
recursiveFind(fullPath, layer + 1, x + dx, y + dy);
}
}
}
}
}
// memoStack.putIfAbsent(key, newPaths);
// memo thought! if layer, x and y are the same as a successful runs then you can use a
// previous run
}
}
}
La cuestión es que mi memoization nunca se usa realmente. Las llamadas recursivas Kinda imita una primera búsqueda en profundidad. ex-
1
/ | \
2 5 8
/\ |\ |\
3 4 6 7 9 10
Por tanto, salvar una carrera voluntad no superposición con otra carrera de ninguna manera el ahorro de rendimiento, ya que está buscando en la parte inferior del árbol antes de volver a bajar la pila de llamadas en marcha. Así que la pregunta es ... ¿cómo memoize esto? o una vez que consiga una ejecución completa de cómo hacer i Recurse de nuevo al principio del árbol para que memoization i escribió obras.
La cadena de prueba que realmente mata el rendimiento es { "ABCDEFGHIJKLMNOPQRSTUVWXYZ", "ABCDEFGHIJKLMNOPQRSTUVWXYZ", "ABCDEFGHIJKLMNOPQRSTUVWXYZ"}; para todos los caminos de longitud 26 (debe devolver 1000000000)
PD. Como primer cartel tiempo sería apreciada algún comentario acerca de mejoras de códigos generales o malos hábitos de programación. Además, ya no he publicado antes de que me haga saber si esta pregunta era clara o formateado mal o demasiado largo etc.
Así lo he descubierto! Gracias en parte a @ גלעד ברקן recomendación 's. Yo estaba originalmente sólo estaba tratando de hacer que funcione diciendo que si alguno cualquiera de los dos caminos tenían ningún mismo índice a continuación, a continuación, fue una ruta completa por lo que nos podría haber más de recursivo que era una simplificación excesiva. Terminé de escribir un pequeño visualizador gráfico de modo que pude ver exactamente lo que estaba viendo. (Este es el primer ejemplo de arriba ({ "ABC", "CBZ", "CZC", "BZZ", "ZAA"} de longitud 3))
L significa Capa- cada capa corresponde a una carta es decir, capa 1 == 'A'
A partir de este determiné que cada nodo puede guardar el número de rutas completas que van de ella. En la imagen sobre esto significa que el nodo L [2] X 1 Y 1 sería dado el número 4, ya que cualquier momento de llegar a ese nodo hay 4 rutas completas.
De todas formas, i memoized en un int [] [] lo que la única cosa que me gustaría hacer desde aquí es hacer que un HashMap modo que tampoco hay tanto espacio desperdiciado.
Aquí está el código que se me ocurrió.
package practiceproblems;
import java.util.ArrayDeque;
public class AlphabetCount {
private int ofLength;
private int paths = 0;
private String[] grid;
//this is the array that we memoize. could be hashmap
private int[][] memoArray;// spec says it initalizes to zero so i am just going with it
//entry point func
public int count(String[] grid, int ofLength) {
//initialize all the member vars
memoArray = new int[grid[0].length()][grid.length];
this.grid = grid;
// this is minus 1 because we already found "A"
this.ofLength = ofLength - 1;
paths = 0;
//saves the previous nodes visited.
ArrayDeque<int[]> goodPathStack = new ArrayDeque<int[]>();
long startTime = System.currentTimeMillis();
for (int j = 0; j < grid.length; j++) {
for (int index = grid[j].indexOf('A'); index >= 0; index = grid[j].indexOf('A', index + 1)) {
//kinda wasteful to clone i would think... but easier because it stays in its stack frame
recursiveFind(goodPathStack.clone(), 0, index, j);
}
}
System.out.println(System.currentTimeMillis() - startTime);
//if we have more than a bil then just return a bil
return paths >= 1_000_000_000 ? 1_000_000_000 : paths;
}
//recursive func
private void recursiveFind(ArrayDeque<int[]> fullPath, int layer, int x, int y) {
//debugging
System.out.println("Preorder " + layer + " " + (x) + " " + (y));
//start pushing onto the path stack so that we know where we have been in a given recursion
int[] pair = { x, y };
fullPath.push(pair);
if (paths >= 1_000_000_000) {
return;
//we found a full path 'A' thru length
} else if (layer == this.ofLength) {
paths++;
//poll is just pop for deques apparently.
// all of these paths start at 'A' which we find manually. so pop last.
// all of these paths incluse the last letter which wouldnt help us because if
// we find the last letter we already know we are at the end.
fullPath.pollFirst();
fullPath.pollLast();
//this is where we save memoization info
//each node on fullPath leads to a full path
for (int[] p : fullPath) {
memoArray[p[0]][p[1]]++;
}
return;
} else if (memoArray[x][y] > 0) {
//this is us using our memoization cache
paths += memoArray[x][y];
fullPath.pollLast();
fullPath.pollFirst();
for (int[] p : fullPath) {
memoArray[p[0]][p[1]] += memoArray[x][y];
}
}
// else if (memoStack.containsKey(key)) {
// for (int[] path : memoStack.get(key)) {
// recursiveFind(fullPath,layer + 1, path[0], path[1]);
// }
// }
else {
int xBound = grid[0].length();
int yBound = grid.length;
//search in all 8 directions for a letter that comes after the one that you are on.
for (int dx = -1; dx <= 1; ++dx) {
for (int dy = -1; dy <= 1; ++dy) {
if (dx != 0 || dy != 0) {
if ((x + dx < xBound && y + dy < yBound) && (x + dx >= 0 && y + dy >= 0)) {
if (grid[y].charAt(x) + 1 == grid[y + dy].charAt(x + dx)) {
recursiveFind(fullPath.clone(), layer + 1, x + dx, y + dy);
}
}
}
}
}
}
// memoStack.putIfAbsent(key, newPaths);
// memo thought! if one runs layer, x and y are the same then you can use a
// previous run
}
}
¡Funciona! y el tiempo necesario para completar los caminos 1_000_000_000 se redujo mucho. Como sub segundos.
Espero que este ejemplo puede ayudar a cualquier otra persona que terminó perplejo por día.