Sum Of Boundary Elements Of Matrix In C++

In matrix operations, identifying and processing specific elements is a common task. Calculating the sum of elements located on the outermost layer of a matrix, often referred to as boundary elements, is a practical requirement in various computational scenarios.

In this article, you will learn how to efficiently calculate the sum of boundary elements of a matrix using C++.

Problem Statement

The problem involves a 2D array or matrix, and the goal is to sum all elements that lie on its perimeter. This means including elements from the first row, the last row, the first column, and the last column. Special care must be taken to ensure that corner elements are not counted multiple times if a simple summation of rows and columns is performed without proper adjustments.

Example

Consider the following 3x3 matrix:

1 2 3
4 5 6
7 8 9

 

The boundary elements are: - From the first row: 1, 2, 3 - From the last row: 7, 8, 9 - From the first column (excluding corners): 4 - From the last column (excluding corners): 6

Summing these distinct boundary elements: 1 + 2 + 3 + 4 + 6 + 7 + 8 + 9 = 40.

Background & Knowledge Prerequisites

To understand this article, you should have a basic understanding of:

• C++ fundamentals: Variables, data types, loops (for loops).
• Arrays/Vectors: How to declare and manipulate 2D arrays or std::vector> in C++.
• Conditional Statements: if and else if statements.

 

For the code examples, we will use std::vector> for matrix representation, which requires including the header.

Use Cases or Case Studies

Calculating the sum of boundary elements can be useful in several applications:

• Image Processing: Analyzing pixels at the edges of an image for border detection, feature extraction, or applying boundary-specific filters.
• Game Development: In grid-based games, determining the status or total value of elements on the play area's perimeter.
• Data Analysis: Summarizing values around the periphery of a dataset represented as a grid, potentially for outlier detection or edge-case analysis.
• Matrix Computations: As a sub-step in more complex matrix algorithms that require distinguishing between interior and boundary elements.
• Resource Management: In simulations, calculating resources or conditions along the "edge" of a simulated area.

 

Solution Approaches

We will explore two distinct approaches to calculate the sum of boundary elements.

Approach 1: Direct Boundary Check during Iteration

This approach involves iterating through every element of the matrix. For each element, it checks if it resides on any of the four boundaries (first row, last row, first column, last column). If the condition is met, the element is added to the total sum. This method naturally handles corner elements by including them once, as the OR conditions ensure an element satisfying any boundary condition is counted.

// Sum of Boundary Elements - Direct Iteration
#include <iostream>
#include <vector> // Required for std::vector
using namespace std;

int main() {
    // Step 1: Define the matrix
    int rows = 3;
    int cols = 3;
    vector<vector<int>> matrix = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    // Step 2: Initialize sum for boundary elements
    int boundarySum = 0;

    // Step 3: Iterate through each element of the matrix
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            // Step 4: Check if the current element is on any boundary
            // An element is on the boundary if its row index is 0 (first row)
            // or rows - 1 (last row), OR its column index is 0 (first column)
            // or cols - 1 (last column).
            if (i == 0 || i == rows - 1 || // Check if it's in the first or last row
                j == 0 || j == cols - 1) { // Check if it's in the first or last column
                boundarySum += matrix[i][j];
            }
        }
    }

    // Step 5: Print the original matrix for reference
    cout << "Matrix:" << endl;
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            cout << matrix[i][j] << " ";
        }
        cout << endl;
    }

    // Step 6: Print the calculated sum
    cout << "Sum of boundary elements (Approach 1): " << boundarySum << endl;

    return 0;
}

Run

Sample Output:

Matrix:
1 2 3
4 5 6
7 8 9
Sum of boundary elements (Approach 1): 40

 

Stepwise Explanation:

1. Matrix Initialization: A std::vector> named matrix is created and populated with sample values. The number of rows and cols is also defined.
2. Sum Initialization: An integer boundarySum is initialized to 0 to store the cumulative sum.
3. Nested Loops: Two nested for loops iterate through each element of the matrix using i for rows and j for columns.
4. Boundary Condition: Inside the inner loop, an if statement checks if the current element matrix[i][j] is on the boundary. This is true if i is the first row index (0), i is the last row index (rows - 1), j is the first column index (0), or j is the last column index (cols - 1).
5. Summation: If the condition is true, matrix[i][j] is added to boundarySum. Because of the || (OR) logic, any element meeting at least one of these conditions (even corners meeting two) is added exactly once per check.
6. Output: The original matrix and the final boundarySum are printed to the console.

 

Approach 2: Iterative Row-Based Summation

This approach processes the matrix row by row. It adds all elements of the first and last rows directly. For any intermediate rows, it only adds the first and last elements (if they exist), effectively capturing the sides without double-counting elements already included from the top and bottom rows. This method is often more intuitive for visualizing the boundary sections.

// Sum of Boundary Elements - Iterative Rows
#include <iostream>
#include <vector> // Required for std::vector
using namespace std;

int main() {
    // Step 1: Define the matrix
    int rows = 3;
    int cols = 3;
    vector<vector<int>> matrix = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    // Step 2: Initialize sum for boundary elements
    int boundarySum = 0;

    // Step 3: Iterate through each row of the matrix
    for (int i = 0; i < rows; ++i) {
        if (i == 0 || i == rows - 1) {
            // Step 4a: If it's the first or last row, add all its elements
            for (int j = 0; j < cols; ++j) {
                boundarySum += matrix[i][j];
            }
        } else {
            // Step 4b: If it's an intermediate row, add only its first and last elements
            // Ensure cols > 0 to prevent out-of-bounds access for empty columns
            if (cols > 0) {
                boundarySum += matrix[i][0]; // Add the first element of the row
                if (cols > 1) {
                    // Add the last element of the row, if there's more than one column
                    boundarySum += matrix[i][cols - 1];
                }
            }
        }
    }

    // Step 5: Print the original matrix for reference
    cout << "Matrix:" << endl;
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            cout << matrix[i][j] << " ";
        }
        cout << endl;
    }

    // Step 6: Print the calculated sum
    cout << "Sum of boundary elements (Approach 2): " << boundarySum << endl;

    return 0;
}

Run

Sample Output:

Matrix:
1 2 3
4 5 6
7 8 9
Sum of boundary elements (Approach 2): 40

 

Stepwise Explanation:

1. Matrix Initialization: Similar to Approach 1, the matrix is defined along with rows and cols.
2. Sum Initialization: boundarySum is initialized to 0.
3. Outer Loop: A single for loop iterates through each row using index i.
4. Row Type Check:
   • If i is the first row (0) or the last row (rows - 1), an inner for loop iterates through all columns (j) of that row, adding matrix[i][j] to boundarySum. This correctly sums the top and bottom borders.

• If i is an intermediate row (neither first nor last), the code only adds matrix[i][0] (the first element of that row) and matrix[i][cols - 1] (the last element of that row), provided cols > 1 to prevent adding the same element twice in a single-column matrix. This handles the left and right borders for the inner rows.

1. Output: The matrix and the final boundarySum are printed.

 

Conclusion

Calculating the sum of boundary elements in a matrix can be achieved through different logical approaches. The direct boundary check method offers a concise way to identify boundary elements by checking conditions for each element. The iterative row-based method provides an alternative by processing full top/bottom rows and then specifically targeting the side elements of intermediate rows. Both methods correctly handle various matrix dimensions, including edge cases like 1x1, 1xN, or Nx1 matrices. Choosing between them often comes down to personal preference for clarity or minor performance considerations depending on matrix size.

Summary

• Problem: Sum elements on the perimeter of a 2D matrix.
• Approach 1: Direct Check: Iterate through all elements; add if (row_is_first || row_is_last || col_is_first || col_is_last). This is robust for all matrix sizes.
• Approach 2: Row-Based Summation:
• For the first and last rows, sum all elements.
• For intermediate rows, sum only the first and last elements.
• Key Consideration: Both approaches correctly handle corner elements without double-counting.
• Usefulness: Relevant in image processing, game development, data analysis, and other grid-based computations.