Teniendo en cuenta una serie de números, gama de productos de todos los demás números regresar sin división?

John :

Hace poco me pidieron la siguiente pregunta de la entrevista por teléfono:

Dada una matriz de enteros, producir una matriz cuyos valores son el producto de cada otro número entero excluyendo el índice actual.

Ejemplo:

[4, 3, 2, 8] -> [3 * 2 * 8, 4 * 2 * 8, 4 * 3 * 8, 4 * 3 * 2] -> [48, 64, 96, 24]

Se me ocurrió código de abajo:

public static BigInteger[] calcArray(int[] input) throws Exception {
    if (input == null) {
        throw new IllegalArgumentException("input is null");
    }
    BigInteger product = calculateProduct(input);
    BigInteger result[] = new BigInteger[input.length];
    for (int i = 0; i < input.length; i++) {
        result[i] = product.divide(BigInteger.valueOf(input[i]));
    }
    return result;
}

private static BigInteger calculateProduct(int[] input) {
    BigInteger result = BigInteger.ONE;
    for (int i = 0; i < input.length; i++) {
        result = result.multiply(BigInteger.valueOf(input[i]));
    }
    return result;
}

Complejidad:

Time Complexity: O(n)
Space Complexity: O(n)

Podemos hacer esto en O (n) la complejidad sin división? También hay alguna manera de reducir la complejidad de espacio si un uso simple matriz entera primitiva.

SomeDude:

Consideremos un elemento situado en el índice i. Mire a su izquierda, digamos que tenemos un producto de elementos hasta el índice i-1. Deja llamada él leftProduct[i]que es el producto de todos los elementos a la izquierda del elemento a i. Del mismo modo permite la llamada rightProduct[i]es producto de todos los elementos a la derecha del elemento a i. A continuación, el resultado de ese índice esoutput[i] = leftProduct[i]*rightProduct[i]

Ahora piensa en cómo llegar leftProduct. Sólo tiene que atravesar la matriz de principio y calcular un producto en ejecución y en cada actualización del elemento leftProductcon el producto actual en ejecución. Del mismo modo se puede calcular rightProductpor la que atraviesa la matriz desde el extremo. Aquí se puede optimizar el espacio mediante la reutilización de la leftProductmatriz mediante una actualización con la multiplicación de la rightProduct.

El siguiente código muestra esto:

public static int[] getProductsExcludingCurrentIndex( int[] arr ) {
     if ( arr == null || arr.length == 0 ) return new int[]{};
     int[] leftProduct = new int[arr.length];
     int runningProduct = 1;
     //Compute left product at each i
     for ( int i = 0; i < arr.length; i++ ) {
       leftProduct[i] = runningProduct;
       runningProduct = runningProduct*arr[i];
    }
    runningProduct = 1;
    //By reverse traversal, we compute right product but at the same time update the left 
    //product, so it will have leftProduct*rightProduct
    for ( int i = arr.length - 1; i >= 0; i-- ) {
        leftProduct[i] = leftProduct[i]*runningProduct;
        runningProduct = runningProduct*arr[i];
    }
    return leftProduct;
}

Complejidad espacial es O(n)- sólo utilizamos una matriz leftProduct, la complejidad es el tiempo O(n).

• Espacio de la complejidad de edición:

Pero si no tenemos en cuenta el espacio utilizado para almacenar la salida, entonces esto es O(1), porque estamos almacenando la producción en leftProductsí misma.

Si no desea estrictamente espacio extra a continuación, lo que conlleva la modificación de su matriz de entrada. La solución de este mediante la modificación de la matriz de entrada a medida que avanza no es posible en absoluto, al menos por lo que yo sé.