The “Number of Laser Beams in a Bank” problem (LeetCode 2125) challenges us to calculate the total count of laser beams within a bank’s security setup. This intriguing problem combines elements of array manipulation and logical deduction to find an optimal solution.

Understanding the Bank’s Security Layout

Imagine a bank’s floor plan represented as a 2D binary matrix. Each row, bank[i], is a string of ‘0’s and ‘1’s. A ‘0’ signifies an empty cell, while a ‘1’ indicates the presence of a security device. Our goal is to determine the total number of laser beams activated across these devices.

Rules for Laser Beams

A laser beam is established between two security devices only if both of the following conditions are met:
1. Different Rows: The two devices must be located on distinct rows, r₁ and r₂, where r₁ < r₂.
2. Clear Path: Crucially, for every row i that lies strictly between r₁ and r₂ (i.e., r₁ < i < r₂), there must be no security devices present in that row. If an intermediate row contains even one device, no beam can be formed between devices in r₁ and r₂.

It’s important to remember that laser beams operate independently; one beam does not interfere with or join another.

Illustrative Examples

Let’s consider the provided examples to solidify our understanding:

• Example 1: bank = ["011001", "000000", "010100", "001000"]
  • In this scenario, a total of 8 beams are generated. For instance, a device at bank[0][1] can form a beam with bank[2][1] because row 1 ("000000") is empty. Similarly, bank[0][5] forms a beam with bank[2][3].
  • Notice that no beams are formed between row 0 and row 3. This is because row 2 ("010100") contains security devices, thus violating the “clear path” condition for any potential beams spanning rows 0 and 3.
• Example 2: bank = ["000", "111", "000"]
  • Here, the output is 0. Although row 1 has devices, there are no two devices located on different rows that satisfy both conditions simultaneously. Specifically, there’s no row before row 1 or after row 1 (that also has devices) with a clear path in between.

An Efficient Approach to Counting Beams

The core insight to solve this problem efficiently is recognizing that laser beams are only formed between security devices located in two distinct rows that are “adjacent” in terms of containing devices. That is, if row A has devices and row B has devices, and all rows between A and B are empty, then every device in A forms a beam with every device in B.

This leads to a straightforward algorithm:

1. Initialization: Begin by setting totalBeams to 0. This variable will accumulate the final count. Also, initialize prevRowCount to 0, which will store the number of security devices in the last encountered row that contained devices.
2. Iterate Through Rows: Go through each row in the bank matrix.
3. Count Devices: For the current row, count the number of ‘1’s. Let’s call this currentRowCount.
4. Calculate Beams:
   • If currentRowCount is greater than 0 (meaning the current row has security devices):
     • Multiply currentRowCount by prevRowCount. This product represents all the new beams formed between devices in the prevRowCount row and the currentRowCount row. Add this product to totalBeams.
     • Update prevRowCount to currentRowCount because this row now becomes the “previous” row for future calculations.
5. Skip Empty Rows: If currentRowCount is 0, simply skip this row. It doesn’t contribute to beam formation itself and doesn’t break a path if it’s an intermediate row (as its count is 0). Crucially, prevRowCount is not updated in this case, preserving the count from the last non-empty row.
6. Final Result: After processing all rows, totalBeams will hold the total number of laser beams.

This approach elegantly handles the “clear path” condition by only forming beams between a prevRowCount and currentRowCount if they are effectively “adjacent” after skipping empty rows.

Conclusion

By understanding the rules of laser beam formation and applying a simple iterative strategy, we can efficiently determine the total number of beams in the bank. The key lies in focusing on non-empty rows and multiplying their device counts to progressively sum the total beams, effectively bypassing the need for complex matrix traversals.