【多次过】【坐标型】Lintcode 553. 炸弹袭击

给一个二维矩阵, 每一个格子都可能是一堵墙 W, 一个敌人 E 或者空 0 (数字 '0'), 返回你可以用一个炸弹杀死的最大敌人数. 炸弹会杀死所有在同一行和同一列没有墙阻隔的敌人, 因为墙比较坚固难以摧毁.

样例

给一个矩阵:

0 E 0 0
E 0 W E
0 E 0 0

返回 3.(在（1, 1）处放炸弹可以杀死 3 个敌人)

注意事项

你只能在空的地方放置炸弹.

解题思路：

每个炸弹可以往四个方向传播，我们可以分析一个方向，然后举一反三，即如果在一个空地放一个炸弹，最多向上炸死多少敌人。

确定状态：

我们假设有敌人或有墙的格子也能放炸弹。

有敌人的格子：格子的敌人被炸死，并继续向上爆炸

有墙的格子：炸弹不能炸死任何敌人

在(1,j)格放一个炸弹，它向上能炸死的敌人数是：

若(i,j)格为空地：(i-1,j)格向上能炸死的敌人数

若(i,j)格为敌人：(i-1,j)格向上能炸死的敌人数 + 1

若(i,j)格为墙：0

子问题：

需要知道(i-1,j)格放一个炸弹向上能炸死的敌人数。

状态：dp[i][j]表示(i,j)格放一个炸弹向上能炸死的敌人数

状态方程：

初始条件：与第0行的dp值和格子内容相关

dp[0][j] = 0 , 若(0,j)格不是敌人

dp[0][j] = 1 , 若(0,j)格是敌人

四个方向：

上面只说明了向上的炸死敌人数，一共四个方向，同理可类似的计算其余方向，注意计算顺序会有改变。

public class Solution {
    /**
     * @param grid: Given a 2D grid, each cell is either 'W', 'E' or '0'
     * @return: an integer, the maximum enemies you can kill using one bomb
     */
    public int maxKilledEnemies(char[][] grid) {
        // write your code here
        if(grid==null || grid.length==0 || grid[0].length==0)
            return 0;
            
        int m = grid.length;
        int n = grid[0].length;
        int[][] dp = new int[m][n];
        int[][] res = new int[m][n];
        
        //up
        for(int i=0; i<m; i++){
            for(int j=0; j<n; j++){
                if(grid[i][j] == 'W')
                    dp[i][j] = 0;
                else{
                    dp[i][j] = 0;
                    if(grid[i][j] == 'E')
                        dp[i][j] = 1;
                    if(i-1 >= 0)
                        dp[i][j] = dp[i-1][j];
                }
                
                res[i][j] += dp[i][j];
            }
        }
        
        //down
        for(int i=m-1; i>=0; i--){
            for(int j=0; j<n; j++){
                if(grid[i][j] == 'W')
                    dp[i][j] = 0;
                else{
                    dp[i][j] = 0;
                    if(grid[i][j] == 'E')
                        dp[i][j] = 1;
                    if(i+1 < m)
                        dp[i][j] = dp[i+1][j];
                }
                
                res[i][j] += dp[i][j];
            }
        }
        
        //left
        for(int i=0; i<m; i++){
            for(int j=0; j<n; j++){
                if(grid[i][j] == 'W')
                    dp[i][j] = 0;
                else{
                    dp[i][j] = 0;
                    if(grid[i][j] == 'E')
                        dp[i][j] = 1;
                    if(j-1 >= 0)
                        dp[i][j] = dp[i][j-1];
                }
                
                res[i][j] += dp[i][j];
            }
        }
        
        //right
        for(int i=0; i<m; i++){
            for(int j=n-1; j>=0; j--){
                if(grid[i][j] == 'W')
                    dp[i][j] = 0;
                else{
                    dp[i][j] = 0;
                    if(grid[i][j] == 'E')
                        dp[i][j] = 1;
                    if(j+1 < n)
                        dp[i][j] = dp[i][j+1];
                }
                
                res[i][j] += dp[i][j];
            }
        }
        
        int result = 0;
        for(int i=0; i<m; i++){
            for(int j=0; j<n; j++){
                if(grid[i][j] == '0'){
                    if(res[i][j] > result)
                        result = res[i][j];
                }
            }
        }
        
        return result;
    }
}