Prefix Sum Of 3D Array

Prerequisite: Prefix Sum – 1D, Prefix Sum -2D
Given a 3-Dimensional array of integers A[L][R][C], where L, R, and C are dimensions of the array (Layer, Row, Column). Find the prefix sum 3d array for it. Let the Prefix sum 3d array be pre[L][R][C]. Here pre[k][i][j] gives the sum of all integers between pre[0][0][0] and pre[k][i][j] (including both).
Example:
Input: A[L][R][C] = {
{{1, 1, 1, 1}, //Layer 1
{1, 1, 1, 1},
{1, 1, 1, 1},
{1, 1, 1, 1}},
{{1, 1, 1, 1}, //Layer 2
{1, 1, 1, 1},
{1, 1, 1, 1},
{1, 1, 1, 1}},
{{1, 1, 1, 1}, //Layer 3
{1, 1, 1, 1},
{1, 1, 1, 1},
{1, 1, 1, 1}},
{{1, 1, 1, 1}, //Layer 4
{1, 1, 1, 1},
{1, 1, 1, 1},
{1, 1, 1, 1}}
}
Output: pre[L][R][C]
Layer 1:
1 2 3 4
2 4 6 8
3 6 9 12
4 8 12 16
Layer 2:
2 4 6 8
4 8 12 16
6 12 18 24
8 16 24 32
Layer 3:
3 6 9 12
6 12 18 24
9 18 27 36
12 24 36 48
Layer 4:
4 8 12 16
8 16 24 32
12 24 36 48
16 32 48 64
Approach: Consider the above image to understand that the cell pre[0][0][0] is at the origin of x, y, z-axis. To fill the pre[][][] Array perform the steps below for calculating the prefix sum.
- The element at (0, 0, 0) is directly filled. pre[0][0][0] = A[0][0][0]
- Fill cells of three edges (parallel to x, y, z-axis and made up of cells) using a prefix sum on the one-dimensional array. These edges have common elements pre[0][0][0]
- Iterate in a for loop [1, L] to calculate the prefix sum for one of the axis. pre[i][0][0] = pre[i – 1][0][0] + A[i][0][0];
- Similarly, iterate in the ranges [1. R] and [1, C] to calculate the prefix sums for the other two axes.
- Fill cells of three sides (parallel to xy, yz, zx-plane and made up of cells) using a prefix sum on the two-dimensional array. These sides have common elements pre[0][0][0].
- Iterate in a for loop [1, L] to calculate the prefix sum for the two-dimensional array.
- Iterate in a for loop [1, R] to calculate the prefix sum for the two-dimensional array.
- Do the following operation. pre[k][i][0] = A[k][i][0] + pre[k – 1][i][0] + pre[k][i – 1][0] – pre[k – 1][i – 1][0]
- Iterate in a for loop [1, R] to calculate the prefix sum for the two-dimensional array.
- Similarly, calculate for the other 2 sides or prefix sums for the other two-dimensional arrays.
- Iterate in a for loop [1, L] to calculate the prefix sum for three-dimensional array pre[][][].
- Iterate in a for loop [1, R] to calculate the prefix sum for three-dimensional array pre[][][].
- Iterate in a for loop [1, C] to calculate the prefix sum for three-dimensional array pre[][][].
- Do the following operation. pre[k][i][j] = A[k][i][j] + pre[k – 1][i][j] + pre[k][i – 1][j] + pre[k][i][j – 1] – pre[k – 1][i – 1][j] – pre[k][i – 1][j – 1] – pre[k – 1][i][j – 1] + pre[k – 1][i – 1][j – 1]
- Iterate in a for loop [1, C] to calculate the prefix sum for three-dimensional array pre[][][].
- Iterate in a for loop [1, R] to calculate the prefix sum for three-dimensional array pre[][][].
- Finally, print the three-dimensional array pre[][][].
Below is the implementation of the above approach.
C++
// C++ program for the above approach.#include <bits/stdc++.h>using namespace std;// Declaring size of the array#define L 4 // Layer#define R 4 // Row#define C 4 // Column// Calculating prefix sum arrayvoid prefixSum3d(int A[L][R][C]){ int pre[L][R][C]; // Step 0: pre[0][0][0] = A[0][0][0]; // Step 1: Filling the first row, // column, and pile of ceils. // Using prefix sum of 1d array for (int i = 1; i < L; i++) pre[i][0][0] = pre[i - 1][0][0] + A[i][0][0]; for (int i = 1; i < R; i++) pre[0][i][0] = pre[0][i - 1][0] + A[0][i][0]; for (int i = 1; i < C; i++) pre[0][0][i] = pre[0][0][i - 1] + A[0][0][i]; // Step 2: Filling the cells // of sides(made up using cells) // which have common element A[0][0][0]. // using prefix sum on 2d array for (int k = 1; k < L; k++) { for (int i = 1; i < R; i++) { pre[k][i][0] = A[k][i][0] + pre[k - 1][i][0] + pre[k][i - 1][0] - pre[k - 1][i - 1][0]; } } for (int i = 1; i < R; i++) { for (int j = 1; j < C; j++) { pre[0][i][j] = A[0][i][j] + pre[0][i - 1][j] + pre[0][i][j - 1] - pre[0][i - 1][j - 1]; } } for (int j = 1; j < C; j++) { for (int k = 1; k < L; k++) { pre[k][0][j] = A[k][0][j] + pre[k - 1][0][j] + pre[k][0][j - 1] - pre[k - 1][0][j - 1]; } } // Step 3: Filling value // in remaining cells using formula for (int k = 1; k < L; k++) { for (int i = 1; i < R; i++) { for (int j = 1; j < C; j++) { pre[k][i][j] = A[k][i][j] + pre[k - 1][i][j] + pre[k][i - 1][j] + pre[k][i][j - 1] - pre[k - 1][i - 1][j] - pre[k][i - 1][j - 1] - pre[k - 1][i][j - 1] + pre[k - 1][i - 1][j - 1]; } } } // Displaying final prefix sum of array for (int k = 0; k < L; k++) { cout << "Layer " << k + 1 << ':' << endl; for (int i = 0; i < R; i++) { for (int j = 0; j < C; j++) { cout << pre[k][i][j] << " "; } cout << endl; } cout << endl; }}// Driver Codeint main(){ int A[L][R][C] = { { { 1, 1, 1, 1 }, // Layer 1 { 1, 1, 1, 1 }, { 1, 1, 1, 1 }, { 1, 1, 1, 1 } }, { { 1, 1, 1, 1 }, // Layer 2 { 1, 1, 1, 1 }, { 1, 1, 1, 1 }, { 1, 1, 1, 1 } }, { { 1, 1, 1, 1 }, // Layer 3 { 1, 1, 1, 1 }, { 1, 1, 1, 1 }, { 1, 1, 1, 1 } }, { { 1, 1, 1, 1 }, // Layer 4 { 1, 1, 1, 1 }, { 1, 1, 1, 1 }, { 1, 1, 1, 1 } } }; prefixSum3d(A); return 0;} |
Java
// java program to calculate prefix sum of 3d arrayimport java.util.*;class GFG { // Declaring size of the array public static int L = 4;// Layer public static int R = 4;// Row public static int C = 4;// Column // Calculating prefix public static void prefixSum3d(int A[][][]) { int pre[][][] = new int[L][R][C]; // Step 0: pre[0][0][0] = A[0][0][0]; // Step 1: Filling the first row,column, and pile of ceils. // Using prefix sum of 1d array for (int i = 1; i < L; i++) pre[i][0][0] = pre[i - 1][0][0] + A[i][0][0]; for (int i = 1; i < R; i++) pre[0][i][0] = pre[0][i - 1][0] + A[0][i][0]; for (int i = 1; i < C; i++) pre[0][0][i] = pre[0][0][i - 1] + A[0][0][i]; // Step 2: Filling the cells of sides(made up using cells) // which have common element A[0][0][0]. // using prefix sum on 2d array for (int k = 1; k < L; k++) { for (int i = 1; i < R; i++) { pre[k][i][0] = A[k][i][0] + pre[k - 1][i][0] + pre[k][i - 1][0] - pre[k - 1][i - 1][0]; } } for (int i = 1; i < R; i++) { for (int j = 1; j < C; j++) { pre[0][i][j] = A[0][i][j] + pre[0][i - 1][j] + pre[0][i][j - 1] - pre[0][i - 1][j - 1]; } } for (int j = 1; j < C; j++) { for (int k = 1; k < L; k++) { pre[k][0][j] = A[k][0][j] + pre[k - 1][0][j] + pre[k][0][j - 1] - pre[k - 1][0][j - 1]; } } // Step 3: Filling value in remaining cells using formula for (int k = 1; k < L; k++) { for (int i = 1; i < R; i++) { for (int j = 1; j < C; j++) { pre[k][i][j] = A[k][i][j] + pre[k - 1][i][j] + pre[k][i - 1][j] + pre[k][i][j - 1] - pre[k - 1][i - 1][j] - pre[k][i - 1][j - 1] - pre[k - 1][i][j - 1] + pre[k - 1][i - 1][j - 1]; } } } // Displaying final prefix sum of array for (int k = 0; k < L; k++) { System.out.println("Layer " + (k + 1) + ":"); for (int i = 0; i < R; i++) { for (int j = 0; j < C; j++) { System.out.print(pre[k][i][j] + " "); } System.out.println(); } System.out.println(); } } // Driver program to test above function public static void main(String[] args) { int A[][][] = { {{1, 1, 1, 1}, // Layer 1 {1, 1, 1, 1 }, {1, 1, 1, 1 }, {1, 1, 1, 1 }}, {{1, 1, 1, 1}, // Layer 2 {1, 1, 1, 1 }, {1, 1, 1, 1 }, {1, 1, 1, 1 }}, {{1, 1, 1, 1}, // Layer 3 {1, 1, 1, 1 }, {1, 1, 1, 1 }, {1, 1, 1, 1 }}, {{1, 1, 1, 1}, // Layer 4 {1, 1, 1, 1 }, {1, 1, 1, 1 }, {1, 1, 1, 1 }} }; prefixSum3d(A); }}// This code is contributed by gajjardeep50. |
Python3
# python program to calculate prefix sum of 3d array# Declaring size of the arrayL = 4 # LayerR = 4 # RowC = 4 # Column# Calculating prefixdef prefixSum3d(A): pre = [[[0 for a in range(C)] for b in range(R)] for d in range(L)] # Step 0: pre[0][0][0] = A[0][0][0] # Step 1: Filling the first row,column, and pile of ceils. # Using prefix sum of 1d array for i in range(1, L): pre[i][0][0] = pre[i - 1][0][0] + A[i][0][0] for i in range(1, R): pre[0][i][0] = pre[0][i - 1][0] + A[0][i][0] for i in range(1, C): pre[0][0][i] = pre[0][0][i - 1] + A[0][0][i] # Step 2: Filling the cells of sides(made up using cells) # which have common element A[0][0][0]. # using prefix sum on 2d array for k in range(1, L): for i in range(1, R): pre[k][i][0] = (A[k][i][0] + pre[k - 1][i][0] + pre[k][i - 1][0] - pre[k - 1][i - 1][0]) for i in range(1, R): for j in range(1, C): pre[0][i][j] = (A[0][i][j] + pre[0][i - 1][j] + pre[0][i][j - 1] - pre[0][i - 1][j - 1]) for j in range(1, C): for k in range(1, L): pre[k][0][j] = (A[k][0][j] + pre[k - 1][0][j] + pre[k][0][j - 1] - pre[k - 1][0][j - 1]) # Step 3: Filling value in remaining cells using formula for k in range(1, L): for i in range(1, R): for j in range(1, C): pre[k][i][j] = (A[k][i][j] + pre[k - 1][i][j] + pre[k][i - 1][j] + pre[k][i][j - 1] - pre[k - 1][i - 1][j] - pre[k][i - 1][j - 1] - pre[k - 1][i][j - 1] + pre[k - 1][i - 1][j - 1]) # Displaying final prefix sum of array for k in range(L): print("Layer", k+1, ":") for i in range(R): for j in range(C): print(pre[k][i][j], end=' ') print() print()# Driver program to test above functionA = [ [[1, 1, 1, 1], # Layer 1 [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]], [[1, 1, 1, 1], # Layer 2 [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]], [[1, 1, 1, 1], # Layer 3 [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]], [[1, 1, 1, 1], # Layer 4 [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]]prefixSum3d(A)# This code is contributed by gajjardeep50. |
C#
// C# program for the above approach.using System;using System.Collections.Generic;class GFG{// Declaring size of the arraystatic int L = 4; // Layerstatic int R = 4; // Rowstatic int C = 4; // Column// Calculating prefix sum arraystatic void prefixSum3d(int [,,]A){ int [,,]pre = new int[L, R, C]; // Step 0: pre[0, 0, 0] = A[0, 0, 0]; // Step 1: Filling the first row, // column, and pile of ceils. // Using prefix sum of 1d array for(int i = 1; i < L; i++) pre[i, 0, 0] = pre[i - 1, 0, 0] + A[i, 0, 0]; for(int i = 1; i < R; i++) pre[0, i, 0] = pre[0, i - 1, 0] + A[0, i, 0]; for(int i = 1; i < C; i++) pre[0, 0, i] = pre[0, 0, i - 1] + A[0, 0, i]; // Step 2: Filling the cells // of sides(made up using cells) // which have common element A[0][0][0]. // using prefix sum on 2d array for(int k = 1; k < L; k++) { for(int i = 1; i < R; i++) { pre[k, i, 0] = A[k, i, 0] + pre[k - 1, i, 0] + pre[k, i - 1, 0] - pre[k - 1, i - 1, 0]; } } for(int i = 1; i < R; i++) { for(int j = 1; j < C; j++) { pre[0, i, j] = A[0, i, j] + pre[0, i - 1, j] + pre[0, i, j - 1] - pre[0, i - 1, j - 1]; } } for(int j = 1; j < C; j++) { for(int k = 1; k < L; k++) { pre[k, 0, j] = A[k, 0, j] + pre[k - 1, 0, j] + pre[k, 0, j - 1] - pre[k - 1, 0, j - 1]; } } // Step 3: Filling value // in remaining cells using formula for(int k = 1; k < L; k++) { for(int i = 1; i < R; i++) { for(int j = 1; j < C; j++) { pre[k, i, j] = A[k, i, j] + pre[k - 1, i, j] + pre[k, i - 1, j] + pre[k, i, j - 1] - pre[k - 1, i - 1, j] - pre[k, i - 1, j - 1] - pre[k - 1, i, j - 1] + pre[k - 1, i - 1, j - 1]; } } } // Displaying final prefix sum of array for(int k = 0; k < L; k++) { Console.WriteLine("Layer " + k + 1 + ":"); for(int i = 0; i < R; i++) { for(int j = 0; j < C; j++) { Console.Write(pre[k, i, j] +" "); } Console.WriteLine(); } Console.WriteLine(); }}// Driver Codepublic static void Main(){ int [,,]A = { { { 1, 1, 1, 1 }, // Layer 1 { 1, 1, 1, 1 }, { 1, 1, 1, 1 }, { 1, 1, 1, 1 } }, { { 1, 1, 1, 1 }, // Layer 2 { 1, 1, 1, 1 }, { 1, 1, 1, 1 }, { 1, 1, 1, 1 } }, { { 1, 1, 1, 1 }, // Layer 3 { 1, 1, 1, 1 }, { 1, 1, 1, 1 }, { 1, 1, 1, 1 } }, { { 1, 1, 1, 1 }, // Layer 4 { 1, 1, 1, 1 }, { 1, 1, 1, 1 }, { 1, 1, 1, 1 } } }; prefixSum3d(A);}}// This code is contributed by SURENDRA_GANGWAR |
Javascript
<script>// Javascript program for the above approach.// Declaring size of the arraylet L = 4; // Layerlet R = 4; // Rowlet C = 4; // Column// Calculating prefix sum arrayfunction prefixSum3d(A) { let pre = new Array(L).fill(0).map( () => new Array(R).fill(0).map( () => new Array(C))); // Step 0: pre[0][0][0] = A[0][0][0]; // Step 1: Filling the first row, // column, and pile of ceils. // Using prefix sum of 1d array for(let i = 1; i < L; i++) pre[i][0][0] = pre[i - 1][0][0] + A[i][0][0]; for(let i = 1; i < R; i++) pre[0][i][0] = pre[0][i - 1][0] + A[0][i][0]; for(let i = 1; i < C; i++) pre[0][0][i] = pre[0][0][i - 1] + A[0][0][i]; // Step 2: Filling the cells // of sides(made up using cells) // which have common element A[0][0][0]. // using prefix sum on 2d array for(let k = 1; k < L; k++) { for(let i = 1; i < R; i++) { pre[k][i][0] = A[k][i][0] + pre[k - 1][i][0] + pre[k][i - 1][0] - pre[k - 1][i - 1][0]; } } for(let i = 1; i < R; i++) { for(let j = 1; j < C; j++) { pre[0][i][j] = A[0][i][j] + pre[0][i - 1][j] + pre[0][i][j - 1] - pre[0][i - 1][j - 1]; } } for(let j = 1; j < C; j++) { for(let k = 1; k < L; k++) { pre[k][0][j] = A[k][0][j] + pre[k - 1][0][j] + pre[k][0][j - 1] - pre[k - 1][0][j - 1]; } } // Step 3: Filling value // in remaining cells using formula for(let k = 1; k < L; k++) { for(let i = 1; i < R; i++) { for(let j = 1; j < C; j++) { pre[k][i][j] = A[k][i][j] + pre[k - 1][i][j] + pre[k][i - 1][j] + pre[k][i][j - 1] - pre[k - 1][i - 1][j] - pre[k][i - 1][j - 1] - pre[k - 1][i][j - 1] + pre[k - 1][i - 1][j - 1]; } } } // Displaying final prefix sum of array for(let k = 0; k < L; k++) { document.write("Layer " + (k + 1) + ":" + "<br>"); for(let i = 0; i < R; i++) { for(let j = 0; j < C; j++) { document.write(pre[k][i][j] + " "); } document.write("<br>"); } document.write("<br>"); }}// Driver Codelet A = [ [ [ 1, 1, 1, 1 ], // Layer 1 [ 1, 1, 1, 1 ], [ 1, 1, 1, 1 ], [ 1, 1, 1, 1 ], ], [ [ 1, 1, 1, 1 ], // Layer 2 [ 1, 1, 1, 1 ], [ 1, 1, 1, 1 ], [ 1, 1, 1, 1 ], ], [ [ 1, 1, 1, 1 ], // Layer 3 [ 1, 1, 1, 1 ], [ 1, 1, 1, 1 ], [ 1, 1, 1, 1 ], ], [ [ 1, 1, 1, 1 ], // Layer 4 [ 1, 1, 1, 1 ], [ 1, 1, 1, 1 ], [ 1, 1, 1, 1 ], ], ];prefixSum3d(A);// This code is contributed by gfgking</script> |
Layer 1: 1 2 3 4 2 4 6 8 3 6 9 12 4 8 12 16 Layer 2: 2 4 6 8 4 8 12 16 6 12 18 24 8 16 24 32 Layer 3: 3 6 9 12 6 12 18 24 9 18 27 36 12 24 36 48 Layer 4: 4 8 12 16 8 16 24 32 12 24 36 48 16 32 48 64
Time Complexity: O(L*R*C)
Auxiliary Space: O(L*R*C)
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 zambiatek!




