Encuentra "camino" en la matriz 2D donde las células de trayectoria suma es igual a "suma"

Devy:

Dada matriz 2D de los enteros positivos. Un "camino" es un conjunto de células adyacentes. Dos células son adyacentes sólo de derecha / izquierda / arriba / abajo (sin diagonal).

La tarea consiste en escribir una función que recibe una matriz 2D mat, un número entero sumy una matriz 2D path(con mismo tamaño que matarray -empty todos ceros).

La función debe comprobar si existen ruta en la que la suma de las celdas igual a sum, debe devolver verdadero si existe y falso en caso contrario.

La matriz pathmarcará el camino (si existen con 1).

Por ejemplo, si mates:

y sum=4

a continuación, pathpuede ser uno de estos tres:

Mi código:

public static void main(String[] args) 
{
    int[][] mat={{2,41,3,14},
                 {2,1,24,7},
                 {2,15,10,54},
                 {63,22,2,4}};

    int[][] path={{0,0,0,0},
                  {0,0,0,0},
                  {0,0,0,0},
                  {0,0,0,0}};
    findSum(mat,4,path);
    //print(mat);
    print(path);
}
public static boolean findSum (int mat[][], int sum, int path[][])
{
    return findSum(mat,sum,path,0,0);
}

public static boolean findSum (int mat[][], int sum, int path[][],int i,int j)
{
    if(sum==0)                      
        return true;

    if(i==mat[0].length||j==mat[1].length)
        return false;       
    boolean result=findSum(mat,sum-mat[i][j],path,i,j+1)||findSum(mat,sum-mat[i][j],path,i+1,j);

    if(result)
        path[i][j]=1;
    return result;

}
private static void print(int[][] arr)
{
    for(int i=0;i<arr[0].length;i++)
    {
        for(int j=0;j<arr[0].length;j++)
        {
            System.out.print(arr[i][j]+" ");
        }
        System.out.println();
    }
}

Mi código funciona bien sólo si la ruta se inicia en (0,0) pero el trabajo does't para otros pathes, por ejemplo, no funciona (array camino es todo cero) para sum=16siquiera que existe tal camino.

Nota:

• La función debe ser recursive- no hay bucles en absoluto.
• Las variables globales no son permitidos (impresión de la matriz no es parte de la pregunta-solamente para la prueba, por tanto, hay un bucle)

daryll:

Niza pregunta ... Aquí está la respuesta. Fue un reto código de diversión;)

public static void main(String[] args) 
{
    int[][] mat={{2,41,3,14},
                 {2,1,24,7},
                 {2,15,10,54},
                 {63,22,2,4}};

    int[][] path={{0,0,0,0},
                  {0,0,0,0},
                  {0,0,0,0},
                  {0,0,0,0}};

    if ( findSum(mat,22,path) ) print(path);
    else System.out.println("No path found");
}
public static boolean findSum (int mat[][], int sum, int path[][])
{
    return startPath(mat, sum, path, -1, 0);
}

// Recursively check every possible starting point
public static boolean startPath(int mat[][], int sum, int path[][], int y, int x)
{
    // Iterate y, goto next column if necessary
    if (++y == mat.length) {
        y = 0;
        ++x;
    }

    if (x == mat[0].length) // Bounds check
        return false;

    if (findSum(mat, sum, path, y, x)) // We've found a successful start point!
    {
        System.out.println("A successful path starts at " + x + ", " + y);
        return true;
    }

    return startPath(mat, sum, path, y, x); // We'll have to keep looking
}

public static boolean findSum (int mat[][], int sum, int path[][], int i, int j)
{
    if(i==mat[0].length || j==mat[1].length || i<0 || j<0) // Bounds check
        return false;

    if (path[i][j] == 1) // Backtracking check
        return false;

    sum -= mat[i][j]; // Decrement sum

    if (sum >= 0) { // More to go? look around
        path[i][j] = 1;

        if (sum == 0) return true; // We made it!

         // If any path finds the end, don't try other paths
        boolean result = findSum(mat, sum, path, i+1, j);
        if (result) return true;
        result = findSum(mat, sum, path, i, j+1);
        if (result) return true;
        result = findSum(mat, sum, path, i-1, j);
        if (result) return true;
        result = findSum(mat, sum, path, i, j-1);

         // There was no successful paths, this is a dead end
        if (!result) path[i][j] = 0;
        return result;
    } else { // We're negative, overshot it
        return false;
    }
}

private static void print(int[][] arr)
{
    for(int i=0;i<arr[0].length;i++)
    {
        for(int j=0;j<arr[0].length;j++)
        {
            System.out.print(arr[i][j]+" ");
        }
        System.out.println();
    }
}

Por cierto comprobar las dimensiones matriz multidimensional que está significando que hacer arr.length and arr[0].lengthsino que está haciendo arr[0].length and arr[1].lengthlo que obtener la misma dimensión dos veces y causar un error si la matriz no era un cuadrado.

También me he permitido moverse en cualquier dirección, indicando la ruta de la intención de prevenir la re-comprobando el mismo nodo nuevo. Esto probablemente podría ser una matriz booleana. Lo siento si mi x / y recursividad es áspera buscando ... Realmente prefiero bucles o .forEach o => o .MAP para que ...

El -1, 0 se puede limpiar quizás con parámetros opcionales y no iterar en la primera pasada.

Déjeme saber si hay algún error o casos extremos que pueda encontrar.