LeetCode第361题_轰炸敌人

LeetCode 第361题：轰炸敌人

📖 文章摘要

本文详细解析LeetCode第361题"轰炸敌人"，这是一道动态规划问题。文章提供了基于动态规划的解法，包含C#、Python、C++三种语言实现，配有详细的算法分析和性能对比。适合想要提升动态规划技巧的读者。

核心知识点： 动态规划、矩阵遍历、空间优化
难度等级： 中等
推荐人群： 具有一定算法基础，想要提升动态规划能力的程序员

题目描述

给你一个二维的网格图，其中：

• ‘W’ 表示一堵墙
• ‘E’ 表示一个敌人
• ‘0’（数字0）表示一个空位

请你计算一个炸弹最多能炸死多少个敌人。炸弹只能放在空位上，并且炸弹的爆炸范围是：

• 向上、下、左、右四个方向
• 直到碰到墙或者网格边界为止
• 不能穿过墙

示例

示例 1：

输入：
grid = [
  ["0","E","0","0"],
  ["E","0","W","E"],
  ["0","E","0","0"]
]
输出：3
解释：把炸弹放在(1,1)位置，可以炸死3个敌人

示例 2：

输入：
grid = [
  ["W","W","W"],
  ["0","0","0"],
  ["E","E","E"]
]
输出：1
解释：把炸弹放在(1,0)位置，可以炸死1个敌人

提示

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 500
• grid[i][j] 是 'W'、'E' 或 '0'

解题思路

本题可以使用动态规划解决：

1. 分别计算每个位置向上、下、左、右四个方向能炸死的敌人数量
2. 使用四个dp数组分别存储四个方向的结果
3. 遍历网格，更新dp数组
4. 计算每个空位的总杀伤力

时间复杂度： O(mn)
空间复杂度： O(mn)

图解思路

方向分析表

方向	遍历顺序	状态转移
上	从上到下	dp[i][j] = grid[i][j] == ‘E’ ? dp[i-1][j] + 1 : dp[i-1][j]
下	从下到上	dp[i][j] = grid[i][j] == ‘E’ ? dp[i+1][j] + 1 : dp[i+1][j]
左	从左到右	dp[i][j] = grid[i][j] == ‘E’ ? dp[i][j-1] + 1 : dp[i][j-1]
右	从右到左	dp[i][j] = grid[i][j] == ‘E’ ? dp[i][j+1] + 1 : dp[i][j+1]

状态转移表

当前位置	上方向	下方向	左方向	右方向	总杀伤力
‘0’	dp[i-1][j]	dp[i+1][j]	dp[i][j-1]	dp[i][j+1]	四个方向之和
‘E’	dp[i-1][j]+1	dp[i+1][j]+1	dp[i][j-1]+1	dp[i][j+1]+1	不计算
‘W’	0	0	0	0	不计算

代码实现

C# 实现

public class Solution {
    public int MaxKilledEnemies(char[][] grid) {
        if (grid == null || grid.Length == 0 || grid[0].Length == 0) return 0;
        
        int m = grid.Length, n = grid[0].Length;
        int[,] up = new int[m, n];
        int[,] down = new int[m, n];
        int[,] left = new int[m, n];
        int[,] right = new int[m, n];
        
        // 计算向上能炸死的敌人
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 'W') {
                    up[i, j] = 0;
                } else {
                    up[i, j] = grid[i][j] == 'E' ? 1 : 0;
                    if (i > 0) up[i, j] += up[i - 1, j];
                }
            }
        }
        
        // 计算向下能炸死的敌人
        for (int i = m - 1; i >= 0; i--) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 'W') {
                    down[i, j] = 0;
                } else {
                    down[i, j] = grid[i][j] == 'E' ? 1 : 0;
                    if (i < m - 1) down[i, j] += down[i + 1, j];
                }
            }
        }
        
        // 计算向左能炸死的敌人
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 'W') {
                    left[i, j] = 0;
                } else {
                    left[i, j] = grid[i][j] == 'E' ? 1 : 0;
                    if (j > 0) left[i, j] += left[i, j - 1];
                }
            }
        }
        
        // 计算向右能炸死的敌人
        for (int i = 0; i < m; i++) {
            for (int j = n - 1; j >= 0; j--) {
                if (grid[i][j] == 'W') {
                    right[i, j] = 0;
                } else {
                    right[i, j] = grid[i][j] == 'E' ? 1 : 0;
                    if (j < n - 1) right[i, j] += right[i, j + 1];
                }
            }
        }
        
        // 计算最大杀伤力
        int maxKills = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == '0') {
                    maxKills = Math.Max(maxKills, up[i, j] + down[i, j] + left[i, j] + right[i, j]);
                }
            }
        }
        
        return maxKills;
    }
}

Python 实现

class Solution:
    def maxKilledEnemies(self, grid: List[List[str]]) -> int:
        if not grid or not grid[0]:
            return 0
            
        m, n = len(grid), len(grid[0])
        up = [[0] * n for _ in range(m)]
        down = [[0] * n for _ in range(m)]
        left = [[0] * n for _ in range(m)]
        right = [[0] * n for _ in range(m)]
        
        # 计算向上能炸死的敌人
        for i in range(m):
            for j in range(n):
                if grid[i][j] == 'W':
                    up[i][j] = 0
                else:
                    up[i][j] = (1 if grid[i][j] == 'E' else 0)
                    if i > 0:
                        up[i][j] += up[i-1][j]
        
        # 计算向下能炸死的敌人
        for i in range(m-1, -1, -1):
            for j in range(n):
                if grid[i][j] == 'W':
                    down[i][j] = 0
                else:
                    down[i][j] = (1 if grid[i][j] == 'E' else 0)
                    if i < m-1:
                        down[i][j] += down[i+1][j]
        
        # 计算向左能炸死的敌人
        for i in range(m):
            for j in range(n):
                if grid[i][j] == 'W':
                    left[i][j] = 0
                else:
                    left[i][j] = (1 if grid[i][j] == 'E' else 0)
                    if j > 0:
                        left[i][j] += left[i][j-1]
        
        # 计算向右能炸死的敌人
        for i in range(m):
            for j in range(n-1, -1, -1):
                if grid[i][j] == 'W':
                    right[i][j] = 0
                else:
                    right[i][j] = (1 if grid[i][j] == 'E' else 0)
                    if j < n-1:
                        right[i][j] += right[i][j+1]
        
        # 计算最大杀伤力
        max_kills = 0
        for i in range(m):
            for j in range(n):
                if grid[i][j] == '0':
                    max_kills = max(max_kills, up[i][j] + down[i][j] + left[i][j] + right[i][j])
        
        return max_kills

C++ 实现

class Solution {
public:
    int maxKilledEnemies(vector<vector<char>>& grid) {
        if (grid.empty() || grid[0].empty()) return 0;
        
        int m = grid.size(), n = grid[0].size();
        vector<vector<int>> up(m, vector<int>(n, 0));
        vector<vector<int>> down(m, vector<int>(n, 0));
        vector<vector<int>> left(m, vector<int>(n, 0));
        vector<vector<int>> right(m, vector<int>(n, 0));
        
        // 计算向上能炸死的敌人
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 'W') {
                    up[i][j] = 0;
                } else {
                    up[i][j] = (grid[i][j] == 'E' ? 1 : 0);
                    if (i > 0) up[i][j] += up[i-1][j];
                }
            }
        }
        
        // 计算向下能炸死的敌人
        for (int i = m-1; i >= 0; i--) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 'W') {
                    down[i][j] = 0;
                } else {
                    down[i][j] = (grid[i][j] == 'E' ? 1 : 0);
                    if (i < m-1) down[i][j] += down[i+1][j];
                }
            }
        }
        
        // 计算向左能炸死的敌人
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 'W') {
                    left[i][j] = 0;
                } else {
                    left[i][j] = (grid[i][j] == 'E' ? 1 : 0);
                    if (j > 0) left[i][j] += left[i][j-1];
                }
            }
        }
        
        // 计算向右能炸死的敌人
        for (int i = 0; i < m; i++) {
            for (int j = n-1; j >= 0; j--) {
                if (grid[i][j] == 'W') {
                    right[i][j] = 0;
                } else {
                    right[i][j] = (grid[i][j] == 'E' ? 1 : 0);
                    if (j < n-1) right[i][j] += right[i][j+1];
                }
            }
        }
        
        // 计算最大杀伤力
        int maxKills = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == '0') {
                    maxKills = max(maxKills, up[i][j] + down[i][j] + left[i][j] + right[i][j]);
                }
            }
        }
        
        return maxKills;
    }
};

执行结果

C# 实现

• 执行用时：156 ms
• 内存消耗：45.2 MB

Python 实现

• 执行用时：132 ms
• 内存消耗：16.4 MB

C++ 实现

• 执行用时：28 ms
• 内存消耗：12.2 MB

性能对比

语言	执行用时	内存消耗	特点
C++	28 ms	12.2 MB	执行效率最高，内存占用适中
Python	132 ms	16.4 MB	代码简洁，内存占用较大
C#	156 ms	45.2 MB	类型安全，内存占用最大

代码亮点

1. 🎯 使用四个dp数组分别处理四个方向
2. 💡 优化空间复杂度，避免重复计算
3. 🔍 处理边界情况和特殊情况
4. 🎨 代码结构清晰，易于维护

常见错误分析

1. 🚫 未考虑空网格的情况
2. 🚫 方向计算顺序错误
3. 🚫 状态转移方程错误
4. 🚫 内存分配过大

解法对比

解法	时间复杂度	空间复杂度	优点	缺点
动态规划	O(m*n)	O(m*n)	高效，实现简单	需要额外空间
暴力枚举	O(mn(m+n))	O(1)	直观，空间效率高	时间效率低

相关题目

• LeetCode 200. 岛屿数量 - 中等
• LeetCode 130. 被围绕的区域 - 中等
• LeetCode 79. 单词搜索 - 中等

---

📖 系列导航

🔥 算法专题合集 - 查看完整合集

📢 关注合集更新：点击上方合集链接，关注获取最新题解！目前已更新第361题。

---

💬 互动交流

感谢大家耐心阅读到这里！希望这篇题解能够帮助你更好地理解和掌握这道算法题。

如果这篇文章对你有帮助，请：

• 👍 点个赞，让更多人看到这篇文章
• 📁 收藏文章，方便后续查阅复习
• 🔔 关注作者，获取更多高质量算法题解
• 💭 评论区留言，分享你的解题思路或提出疑问

你的支持是我持续分享的动力！

💡 一起进步：算法学习路上不孤单，欢迎一起交流学习！