产品阵列之谜

给定n个整数的数组arr []，请构造乘积数组prod [](大小相同)，以使prod [i]等于arr []的所有元素(除arr [i]之外)的乘积。在O(n)时间内求解无除法运算符。
例子 ：

Input: arr[]  = {10, 3, 5, 6, 2}
Output: prod[]  = {180, 600, 360, 300, 900}
3 * 5 * 6 * 2 product of other array 
elements except 10 is 180
10 * 5 * 6 * 2 product of other array 
elements except 3 is 600
10 * 3 * 6 * 2 product of other array 
elements except 5 is 360
10 * 3 * 5 * 2 product of other array 
elements except 6 is 300
10 * 3 * 6 * 5 product of other array 
elements except 2 is 900


Input: arr[]  = {1, 2, 3, 4, 5}
Output: prod[]  = {120, 60, 40, 30, 24 }
2 * 3 * 4 * 5  product of other array 
elements except 1 is 120
1 * 3 * 4 * 5  product of other array 
elements except 2 is 60
1 * 2 * 4 * 5  product of other array 
elements except 3 is 40
1 * 2 * 3 * 5  product of other array 
elements except 4 is 30
1 * 2 * 3 * 4  product of other array 
elements except 5 is 24

天真的解决方案：
方法：创建两个额外的空间，即两个额外的数组，用于存储从开始到索引的所有数组元素的乘积；另一个数组，存储从数组末尾到该索引的所有数组元素的乘积。
要获得不包含该索引的乘积，请将前缀乘积最多乘以索引i-1，然后将后缀乘积乘以最大索引i + 1。
算法：

1. 创建两个长度为n的数组前缀和后缀，即原始数组的长度，初始化prefix [0] = 1和后缀[n-1] = 1，并初始化另一个数组来存储乘积。
2. 从第二个索引遍历数组到结尾。
3. 对于每个索引，我将prefix [i]更新为prefix [i] = prefix [i-1] * array [i-1] ，即从数组开始存储乘积直至i-1索引。
4. 从倒数第二个索引开始遍历数组。
5. 对于每个索引，我将后缀[i]更新为后缀[i] =后缀[i + 1] * array [i + 1] ，即从乘积的末尾存储直到i + 1索引的乘积
6. 从头到尾遍历数组。
7. 对于每个索引i ，输出将为prefix [i] * suffix [i] ，即该元素之外的数组元素的乘积。

Java

class ProductArray {
    /* Function to print product array
    for a given array arr[] of size n */
    void productArray(int arr[], int n)
    {
 
        // Base case
        if (n == 1) {
            System.out.print(0);
            return;
        }
        // Initialize memory to all arrays
        int left[] = new int[n];
        int right[] = new int[n];
        int prod[] = new int[n];
 
        int i, j;
 
        /* Left most element of left array
is always 1 */
        left[0] = 1;
 
        /* Rightmost most element of right
array is always 1 */
        right[n - 1] = 1;
 
        /* Construct the left array */
        for (i = 1; i < n; i++)
            left[i] = arr[i - 1] * left[i - 1];
 
        /* Construct the right array */
        for (j = n - 2; j >= 0; j--)
            right[j] = arr[j + 1] * right[j + 1];
 
        /* Construct the product array using
        left[] and right[] */
        for (i = 0; i < n; i++)
            prod[i] = left[i] * right[i];
 
        /* print the constructed prod array */
        for (i = 0; i < n; i++)
            System.out.print(prod[i] + " ");
 
        return;
    }
 
    /* Driver program to test the aboe function */
    public static void main(String[] args)
    {
        ProductArray pa = new ProductArray();
        int arr[] = { 10, 3, 5, 6, 2 };
        int n = arr.length;
        System.out.println("The product array is : ");
        pa.productArray(arr, n);
    }
}
 
// This code has been contributed by Mayank Jaiswal

C#

using System;
 
class GFG {
 
    /* Function to print product array
    for a given array arr[] of size n */
    static void productArray(int[] arr, int n)
    {
 
        // Base case
        if (n == 1) {
            Console.Write(0);
            return;
        }
        // Initialize memory to all arrays
        int[] left = new int[n];
        int[] right = new int[n];
        int[] prod = new int[n];
 
        int i, j;
 
        /* Left most element of left array
        is always 1 */
        left[0] = 1;
 
        /* Rightmost most element of right
        array is always 1 */
        right[n - 1] = 1;
 
        /* Construct the left array */
        for (i = 1; i < n; i++)
            left[i] = arr[i - 1] * left[i - 1];
 
        /* Construct the right array */
        for (j = n - 2; j >= 0; j--)
            right[j] = arr[j + 1] * right[j + 1];
 
        /* Construct the product array using
        left[] and right[] */
        for (i = 0; i < n; i++)
            prod[i] = left[i] * right[i];
 
        /* print the constructed prod array */
        for (i = 0; i < n; i++)
            Console.Write(prod[i] + " ");
 
        return;
    }
 
    /* Driver program to test the aboe function */
    public static void Main()
    {
        int[] arr = { 10, 3, 5, 6, 2 };
        int n = arr.Length;
        Console.Write("The product array is :\n");
 
        productArray(arr, n);
    }
}
 
// This code is contributed by nitin mittal.

输出

The product array is: 
180 600 360 300 900 

C++

// C++ implementation of above approach
#include 
using namespace std;
 
/* Function to print product array
for a given array arr[] of size n */
void productArray(int arr[], int n)
{
 
    // Base case
    if (n == 1) {
        cout << 0;
        return;
    }
    /* Allocate memory for temporary
arrays left[] and right[] */
    int* left = new int[sizeof(int) * n];
    int* right = new int[sizeof(int) * n];
 
    /* Allocate memory for the product array */
    int* prod = new int[sizeof(int) * n];
 
    int i, j;
 
    /* Left most element of left
array is always 1 */
    left[0] = 1;
 
    /* Rightmost most element of right
array is always 1 */
    right[n - 1] = 1;
 
    /* Construct the left array */
    for (i = 1; i < n; i++)
        left[i] = arr[i - 1] * left[i - 1];
 
    /* Construct the right array */
    for (j = n - 2; j >= 0; j--)
        right[j] = arr[j + 1] * right[j + 1];
 
    /* Construct the product array using
        left[] and right[] */
    for (i = 0; i < n; i++)
        prod[i] = left[i] * right[i];
 
    /* print the constructed prod array */
    for (i = 0; i < n; i++)
        cout << prod[i] << " ";
 
    return;
}
 
/* Driver code*/
int main()
{
    int arr[] = { 10, 3, 5, 6, 2 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "The product array is: \n";
    productArray(arr, n);
}
 
// This is code is contributed by rathbhupendra

C

#include 
#include 
 
/* Function to print product array
for a given array arr[] of size n */
void productArray(int arr[], int n)
{
 
    // Base case
    if (n == 1) {
        printf("0");
        return;
    }
 
    /* Allocate memory for temporary
arrays left[] and right[] */
    int* left = (int*)malloc(
        sizeof(int) * n);
    int* right = (int*)malloc(
        sizeof(int) * n);
 
    /* Allocate memory for the product array */
    int* prod = (int*)malloc(
        sizeof(int) * n);
 
    int i, j;
 
    /* Left most element of left array
is always 1 */
    left[0] = 1;
 
    /* Rightmost most element of right
array is always 1 */
    right[n - 1] = 1;
 
    /* Construct the left array */
    for (i = 1; i < n; i++)
        left[i] = arr[i - 1] * left[i - 1];
 
    /* Construct the right array */
    for (j = n - 2; j >= 0; j--)
        right[j] = arr[j + 1] * right[j + 1];
 
    /* Construct the product array using
    left[] and right[] */
    for (i = 0; i < n; i++)
        prod[i] = left[i] * right[i];
 
    /* print the constructed prod array */
    for (i = 0; i < n; i++)
        printf("%d ", prod[i]);
 
    return;
}
 
/* Driver program to test above functions */
int main()
{
    int arr[] = { 10, 3, 5, 6, 2 };
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("The product array is: \n");
    productArray(arr, n);
    getchar();
}

Java

class ProductArray {
    /* Function to print product array
    for a given array arr[] of size n */
    void productArray(int arr[], int n)
    {
 
        // Base case
        if (n == 1) {
            System.out.print(0);
            return;
        }
        // Initialize memory to all arrays
        int left[] = new int[n];
        int right[] = new int[n];
        int prod[] = new int[n];
 
        int i, j;
 
        /* Left most element of left array
is always 1 */
        left[0] = 1;
 
        /* Rightmost most element of right
array is always 1 */
        right[n - 1] = 1;
 
        /* Construct the left array */
        for (i = 1; i < n; i++)
            left[i] = arr[i - 1] * left[i - 1];
 
        /* Construct the right array */
        for (j = n - 2; j >= 0; j--)
            right[j] = arr[j + 1] * right[j + 1];
 
        /* Construct the product array using
        left[] and right[] */
        for (i = 0; i < n; i++)
            prod[i] = left[i] * right[i];
 
        /* print the constructed prod array */
        for (i = 0; i < n; i++)
            System.out.print(prod[i] + " ");
 
        return;
    }
 
    /* Driver program to test the above function */
    public static void main(String[] args)
    {
        ProductArray pa = new ProductArray();
        int arr[] = { 10, 3, 5, 6, 2 };
        int n = arr.length;
        System.out.println("The product array is : ");
        pa.productArray(arr, n);
    }
}
 
// This code has been contributed by Mayank Jaiswal

Python3

# Python implementation of the above approach
 
# Function to print product array for a given array
# arr[] of size n
 
 
def productArray(arr, n):
 
    # Base case
    if(n == 1):
        print(0)
        return
         
    # Allocate memory for temporary arrays left[] and right[]
    left = [0]*n
    right = [0]*n
 
    # Allocate memory for the product array
    prod = [0]*n
 
    # Left most element of left array is always 1
    left[0] = 1
 
    # Rightmost most element of right array is always 1
    right[n - 1] = 1
 
    # Construct the left array
    for i in range(1, n):
        left[i] = arr[i - 1] * left[i - 1]
 
    # Construct the right array
    for j in range(n-2, -1, -1):
        right[j] = arr[j + 1] * right[j + 1]
 
    # Construct the product array using
    # left[] and right[]
    for i in range(n):
        prod[i] = left[i] * right[i]
 
    # print the constructed prod array
    for i in range(n):
        print(prod[i], end =' ')
 
 
# Driver code
arr = [10, 3, 5, 6, 2]
n = len(arr)
print("The product array is:")
productArray(arr, n)
 
# This code is contributed by ankush_953

C＃

using System;
 
class GFG {
 
    /* Function to print product array
    for a given array arr[] of size n */
    static void productArray(int[] arr, int n)
    {
 
        // Base case
        if (n == 1) {
            Console.Write(0);
            return;
        }
        // Initialize memory to all arrays
        int[] left = new int[n];
        int[] right = new int[n];
        int[] prod = new int[n];
 
        int i, j;
 
        /* Left most element of left array
        is always 1 */
        left[0] = 1;
 
        /* Rightmost most element of right
        array is always 1 */
        right[n - 1] = 1;
 
        /* Construct the left array */
        for (i = 1; i < n; i++)
            left[i] = arr[i - 1] * left[i - 1];
 
        /* Construct the right array */
        for (j = n - 2; j >= 0; j--)
            right[j] = arr[j + 1] * right[j + 1];
 
        /* Construct the product array using
        left[] and right[] */
        for (i = 0; i < n; i++)
            prod[i] = left[i] * right[i];
 
        /* print the constructed prod array */
        for (i = 0; i < n; i++)
            Console.Write(prod[i] + " ");
 
        return;
    }
 
    /* Driver program to test the above function */
    public static void Main()
    {
        int[] arr = { 10, 3, 5, 6, 2 };
        int n = arr.Length;
        Console.Write("The product array is :\n");
 
        productArray(arr, n);
    }
}
 
// This code is contributed by nitin mittal.

的PHP

= 0; $j--)
        $right[$j] = $arr[$j + 1] *
                    $right[$j + 1];
 
    // Construct the product array
    // using left[] and right[]
    for ($i = 0; $i < $n; $i++)
        $prod[$i] = $left[$i] *
                    $right[$i];
 
    // print the constructed prod array
    for ($i = 0; $i < $n; $i++)
        echo $prod[$i], " ";
 
    return;
}
 
// Driver Code
$arr = array(10, 3, 5, 6, 2);
$n = count($arr);
echo "The product array is : \n";
productArray($arr, $n);
 
// This code has been contributed by anuj_67.
?>

Java脚本

    /* Function to print product array
    for a given array arr[] of size n */
    function productArray(arr, n)
    {
  
        // Base case
        if (n == 1) {
            document.write(0);
            return;
        }
         
        // Initialize memory to all arrays
        let left = new Array(n);
        let right = new Array(n);
        let prod = new Array(n);
  
        let i, j;
  
        /* Left most element of left array
        is always 1 */
        left[0] = 1;
  
        /* Rightmost most element of right
        array is always 1 */
        right[n - 1] = 1;
  
        /* Construct the left array */
        for (i = 1; i < n; i++)
            left[i] = arr[i - 1] * left[i - 1];
  
        /* Construct the right array */
        for (j = n - 2; j >= 0; j--)
            right[j] = arr[j + 1] * right[j + 1];
  
        /* Construct the product array using
        left[] and right[] */
        for (i = 0; i < n; i++)
            prod[i] = left[i] * right[i];
  
        /* print the constructed prod array */
        for (i = 0; i < n; i++)
            document.write(prod[i] + " ");
  
        return;
    }
     
    // Driver code
    let arr = [ 10, 3, 5, 6, 2 ];
    let n = arr.length;
    document.write("The product array is :" + "</br>");
 
    productArray(arr, n);
 
// This code is contributed by mukesh07.

复杂度分析：

• 时间复杂度： O(n)。
  该数组需要遍历3次，因此时间复杂度为O(n)。
• 空间复杂度： O(n)。
  需要两个额外的数组和一个用于存储输出的数组，因此空间复杂度为O(n)

注意：以上方法可以优化为在空间复杂度O(1)中工作。感谢Dileep提供以下解决方案。
高效的解决方案：
方法：在先前的解决方案中，创建了两个额外的数组来存储前缀和后缀，在此解决方案中，将前缀和后缀乘积存储在输出数组(或乘积数组)本身中。从而减少了所需的空间。
算法：

1. 创建一个数组乘积，并将其值初始化为1，变量temp = 1。
2. 从头到尾遍历数组。
3. 对于每个索引，我将product [i]更新为product [i] = temp和temp = temp * array [i] ，即从数组开始存储乘积直至i-1索引。
4. 初始化temp = 1并从最后一个索引开始遍历数组。
5. 对于每个索引，我将product [i]更新为product [i] = product [i] * temp和temp = temp * array [i] ，即，将乘积乘以直到数组末尾的i + 1索引。
6. 打印产品阵列。

C++

// C++ implementation of above approach
#include 
using namespace std;
 
/* Function to print product array
for a given array arr[] of size n */
void productArray(int arr[], int n)
{
 
    // Base case
    if (n == 1) {
        cout << 0;
        return;
    }
 
    int i, temp = 1;
 
    /* Allocate memory for the product array */
    int* prod = new int[(sizeof(int) * n)];
 
    /* Initialize the product array as 1 */
    memset(prod, 1, n);
 
    /* In this loop, temp variable contains product of
       elements on left side excluding arr[i] */
    for (i = 0; i < n; i++) {
        prod[i] = temp;
        temp *= arr[i];
    }
 
    /* Initialize temp to 1
    for product on right side */
    temp = 1;
 
    /* In this loop, temp variable contains product of
       elements on right side excluding arr[i] */
    for (i = n - 1; i >= 0; i--) {
        prod[i] *= temp;
        temp *= arr[i];
    }
 
    /* print the constructed prod array */
    for (i = 0; i < n; i++)
        cout << prod[i] << " ";
 
    return;
}
 
// Driver Code
int main()
{
    int arr[] = { 10, 3, 5, 6, 2 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "The product array is: \n";
    productArray(arr, n);
}
 
// This code is contributed by rathbhupendra

Java

class ProductArray {
    void productArray(int arr[], int n)
    {
 
        // Base case
        if (n == 1) {
            System.out.print("0");
            return;
        }
 
        int i, temp = 1;
 
        /* Allocate memory for the product array */
        int prod[] = new int[n];
 
        /* Initialize the product array as 1 */
        for (int j = 0; j < n; j++)
            prod[j] = 1;
 
        /* In this loop, temp variable contains product of
           elements on left side excluding arr[i] */
        for (i = 0; i < n; i++) {
            prod[i] = temp;
            temp *= arr[i];
        }
 
        /* Initialize temp to 1 for product on right side */
        temp = 1;
 
        /* In this loop, temp variable contains product of
           elements on right side excluding arr[i] */
        for (i = n - 1; i >= 0; i--) {
            prod[i] *= temp;
            temp *= arr[i];
        }
 
        /* print the constructed prod array */
        for (i = 0; i < n; i++)
            System.out.print(prod[i] + " ");
 
        return;
    }
 
    /* Driver program to test above functions */
    public static void main(String[] args)
    {
        ProductArray pa = new ProductArray();
        int arr[] = { 10, 3, 5, 6, 2 };
        int n = arr.length;
        System.out.println("The product array is : ");
        pa.productArray(arr, n);
    }
}
 
// This code has been contributed by Mayank Jaiswal

Python3

# Python3 program for A Product Array Puzzle
def productArray(arr, n):
 
    # Base case
    if n == 1:
        print(0)
        return
 
    i, temp = 1, 1
 
    # Allocate memory for the product array
    prod = [1 for i in range(n)]
 
    # Initialize the product array as 1
 
    # In this loop, temp variable contains product of
    # elements on left side excluding arr[i]
    for i in range(n):
        prod[i] = temp
        temp *= arr[i]
 
    # Initialize temp to 1 for product on right side
    temp = 1
 
    # In this loop, temp variable contains product of
    # elements on right side excluding arr[i]
    for i in range(n - 1, -1, -1):
        prod[i] *= temp
        temp *= arr[i]
 
    # Print the constructed prod array
    for i in range(n):
        print(prod[i], end = " ")
 
    return
 
# Driver Code
arr = [10, 3, 5, 6, 2]
n = len(arr)
print("The product array is: n")
productArray(arr, n)
 
# This code is contributed by mohit kumar

C＃

using System;
 
class GFG {
 
    static void productArray(int[] arr, int n)
    {
 
        // Base case
        if (n == 1) {
            Console.Write(0);
            return;
        }
        int i, temp = 1;
 
        /* Allocate memory for the product
        array */
        int[] prod = new int[n];
 
        /* Initialize the product array as 1 */
        for (int j = 0; j < n; j++)
            prod[j] = 1;
 
        /* In this loop, temp variable contains
        product of elements on left side
        excluding arr[i] */
        for (i = 0; i < n; i++) {
            prod[i] = temp;
            temp *= arr[i];
        }
 
        /* Initialize temp to 1 for product on
        right side */
        temp = 1;
 
        /* In this loop, temp variable contains
        product of elements on right side
        excluding arr[i] */
        for (i = n - 1; i >= 0; i--) {
            prod[i] *= temp;
            temp *= arr[i];
        }
 
        /* print the constructed prod array */
        for (i = 0; i < n; i++)
            Console.Write(prod[i] + " ");
 
        return;
    }
 
    /* Driver program to test above functions */
    public static void Main()
    {
        int[] arr = { 10, 3, 5, 6, 2 };
        int n = arr.Length;
        Console.WriteLine("The product array is : ");
 
        productArray(arr, n);
    }
}
 
// This code is contributed by nitin mittal.

的PHP

= 0; $i--)
        {
            $prod[$i] *= $temp;
            $temp *= $arr[$i];
        }
 
        /* print the constructed
           prod array */
        for ($i = 0; $i < $n; $i++)
            echo $prod[$i], " ";
 
        return;
    }
 
        // Driver Code   
        $arr = array(10, 3, 5, 6, 2);
        $n = count($arr);
        echo "The product array is : \n";
        productArray($arr, $n);
     
// This code is contributed by anuj_67.
?>

输出

The product array is: 
180 600 360 300 900 

复杂度分析：

• 时间复杂度： O(n)。
  原始数组仅需要遍历一次，因此时间复杂度是恒定的。
• 空间复杂度： O(n)。
  即使删除了多余的数组，由于仍然需要乘积数组，所以空间复杂度仍为O(n)。

另一种方法：

存储所有元素的乘积是一个变量，然后迭代该数组并在新数组中添加product / current_index_value。然后返回这个新数组。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
 
long* productExceptSelf(int a[], int n)
{
    long prod = 1;
    long flag = 0;
 
    // product of all elements
    for (int i = 0; i < n; i++) {
 
        // counting number of elements
        // which have value
        // 0
        if (a[i] == 0)
            flag++;
        else
            prod *= a[i];
    }
 
    // creating a new array of size n
    long* arr = new long[n];
 
    for (int i = 0; i < n; i++) {
 
        // if number of elements in
        // array with value 0
        // is more than 1 than each
        // value in new array
        // will be equal to 0
        if (flag > 1) {
            arr[i] = 0;
        }
 
        // if no element having value
        // 0 than we will
        // insert product/a[i] in new array
        else if (flag == 0)
            arr[i] = (prod / a[i]);
 
        // if 1 element of array having
        // value 0 than all
        // the elements except that index
        // value , will be
        // equal to 0
        else if (flag == 1 && a[i] != 0) {
            arr[i] = 0;
        }
 
        // if(flag == 1 && a[i] == 0)
        else
            arr[i] = prod;
    }
    return arr;
}
 
// Driver Code
int main()
{
    int n = 5;
    int array[] = { 10, 3, 5, 6, 2 };
 
    long* ans;
    ans = productExceptSelf(array, n);
 
    for (int i = 0; i < n; i++) {
        cout << ans[i] << " ";
    }
    // cout<<"GFG!";
    return 0;
}
 
// This code is contributed by RohitOberoi.

Java

// Java program for the above approach
import java.io.*;
import java.util.*;
 
class Solution {
 
    public static long[] productExceptSelf(int a[], int n)
    {
        long prod = 1;
        long flag = 0;
 
        // product of all elements
        for (int i = 0; i < n; i++) {
 
            // counting number of elements
            // which have value
            // 0
            if (a[i] == 0)
                flag++;
            else
                prod *= a[i];
        }
 
        // creating a new array of size n
        long arr[] = new long[n];
        for (int i = 0; i < n; i++) {
 
            // if number of elements in
            // array with value 0
            // is more than 1 than each
            // value in new array
            // will be equal to 0
            if (flag > 1) {
                arr[i] = 0;
            }
 
            // if no element having value
            // 0 than we will
            // insert product/a[i] in new array
            else if (flag == 0)
                arr[i] = (prod / a[i]);
 
            // if 1 element of array having
            // value 0 than all
            // the elements except that index
            // value , will be
            // equal to 0
            else if (flag == 1 && a[i] != 0) {
                arr[i] = 0;
            }
 
            // if(flag == 1 && a[i] == 0)
            else
                arr[i] = prod;
        }
        return arr;
    }
 
    // Driver Code
    public static void main(String args[])
        throws IOException
    {
        int n = 5;
        int[] array = { 10, 3, 5, 6, 2 };
 
        Solution ob = new Solution();
        long[] ans = new long[n];
        ans = ob.productExceptSelf(array, n);
 
        for (int i = 0; i < n; i++) {
            System.out.print(ans[i] + " ");
        }
    }
}
 
// This code is contributed by Kapil Kumar (kapilkumar2001)

输出

180 600 360 300 900 

时间复杂度：O(n)

原始数组仅需要遍历一次，因此时间复杂度是恒定的。