Bomb Enemy

class Solution {
    public int maxEnemiesDestroyed(char[][] matrix) {
        if (matrix.length == 0)
            return 0;

        int totalRows = matrix.length;
        int totalCols = matrix[0].length;

        int maxEnemies = 0, rowEnemies = 0;
        int[] colEnemies = new int[totalCols];

        for (int i = 0; i < totalRows; ++i) {
            for (int j = 0; j < totalCols; ++j) {

                // Reset row enemies count if needed
                if (j == 0 || matrix[i][j - 1] == 'W') {
                    rowEnemies = 0;
                    for (int x = j; x < totalCols; ++x) {
                        if (matrix[i][x] == 'W')
                            break;
                        else if (matrix[i][x] == 'E')
                            rowEnemies += 1;
                    }
                }

                // Reset column enemies count if needed
                if (i == 0 || matrix[i - 1][j] == 'W') {
                    colEnemies[j] = 0;
                    for (int x = i; x < totalRows; ++x) {
                        if (matrix[x][j] == 'W')
                            break;
                        else if (matrix[x][j] == 'E')
                            colEnemies[j] += 1;
                    }
                }

                // Calculate maximum for empty cell
                if (matrix[i][j] == '0') {
                    maxEnemies = Math.max(maxEnemies, rowEnemies + colEnemies[j]);
                }
            }
        }

        return maxEnemies;
    }
}

The "Bomb Enemy" problem involves finding the maximum number of enemies ('E') that can be destroyed with one bomb, placed in an empty cell ('0'), within a grid. The bomb destroys enemies in the same row and column until it hits a wall ('W') which blocks the explosion path.

• Utilize a 2D grid (matrix) where rows and columns can contain enemies ('E'), walls ('W'), or empty spaces ('0').
• Initialize variables for maximum enemies destroyed (maxEnemies), current row enemies count (rowEnemies), and an array to track enemies in each column (colEnemies).
• Loop through each cell in the grid:
  • At the start of each row or after encountering a wall, recompute the possible enemies destroyed in that row to the right until another wall or end.
  • Similarly, at the start of each column or after encountering a wall above, recompute the possible enemies in that column downwards.
  • If an empty space ('0') is found, check the total enemies that can be destroyed from the current position combined from both row and column counts.
  • Update maxEnemies if the counted enemies at that position exceed the previous maximum recorded.
• Return the maximum number of enemies that can be destroyed from a single bomb placement.

This solution efficiently computes possible enemies that can be destroyed in each direction (row and column) only when necessary, such as after a wall or at grid boundaries, significantly optimizing the approach. The output provides the highest count of enemies destroyed by placing a bomb in an optimal position.

class Solution:
    def maximumEnemiesKilled(self, matrix: List[List[str]]) -> int:
        if not matrix:
            return 0

        row_len, col_len = len(matrix), len(matrix[0])

        highest_kills = 0
        horizontal_kills = 0
        vertical_kills = [0] * col_len

        for i in range(row_len):
            for j in range(col_len):
                if j == 0 or matrix[i][j - 1] == 'W':
                    horizontal_kills = 0
                    for m in range(j, col_len):
                        if matrix[i][m] == 'W':
                            break
                        elif matrix[i][m] == 'E':
                            horizontal_kills += 1

                if i == 0 or matrix[i - 1][j] == 'W':
                    vertical_kills[j] = 0
                    for n in range(i, row_len):
                        if matrix[n][j] == 'W':
                            break
                        elif matrix[n][j] == 'E':
                            vertical_kills[j] += 1

                if matrix[i][j] == '0':
                    total_enemies = horizontal_kills + vertical_kills[j]
                    highest_kills = max(highest_kills, total_enemies)

        return highest_kills

The "Bomb Enemy" problem requires calculating the maximum number of enemies that can be killed by placing a bomb on an empty spot in a given grid layout, where 'E' represents an enemy, '0' represents an empty space, and 'W' represents a wall which blocks blasts both vertically and horizontally.

The solution leverages a Python class Solution with the method maximumEnemiesKilled, which takes a matrix as input. The approach involves computing the maximum number of enemies that can be destroyed from each empty spot by iterating through each cell in the grid and calculating potential kills in both horizontal and vertical directions unless obstructed by walls. Here's a step-by-step explanation of the method:

1. Initialize variables for the dimensions of the matrix, row_len and col_len.
2. Define highest_kills to keep track of the maximum number of enemies that can be killed from a single bomb placement.
3. Use horizontal_kills for the number of enemies that can be killed in the current row up to a wall.
4. Initialize vertical_kills, an array storing the vertical kill counts per column up to a wall, reset upon encountering a wall.
5. Iterate over each cell in the matrix using nested loops to check row by row and column by column:
   • If the start of a row or a wall is encountered (j == 0 or matrix[i][j - 1] == 'W'), recalculate the horizontal_kills from the current position to the end of the row or up to the next wall.
   • Similarly, if the start of a column or a wall is encountered (i == 0 or matrix[i - 1][j] == 'W'), recalculate vertical_kills for that column from the current position to the end of the column or up to the next wall.
6. When an empty cell ('0') is found, combine the horizontal and vertical enemy counts (horizontal_kills + vertical_kills[j]), and update highest_kills if this sum is greater than the current highest_kills.
7. Continue this for all cells in the matrix.

After all iterations, return the value of highest_kills as the result, indicating the maximum enemies that can be killed by placing a bomb in an optimal position. This solution efficiently handles the matrix without redundant calculations by dynamically updating kill counts only when necessary, driven by changes caused by walls.