【每日一题】- 2019-10-21 - LCP 4. 覆盖

[azl397985856]

你有一块棋盘，棋盘上有一些格子已经坏掉了。你还有无穷块大小为1 * 2的多米诺骨牌，你想把这些骨牌不重叠地覆盖在完好的格子上，请找出你最多能在棋盘上放多少块骨牌？这些骨牌可以横着或者竖着放。

 

输入：n, m代表棋盘的大小；broken是一个b * 2的二维数组，其中每个元素代表棋盘上每一个坏掉的格子的位置。

输出：一个整数，代表最多能在棋盘上放的骨牌数。

 

示例 1：

输入：n = 2, m = 3, broken = [[1, 0], [1, 1]]
输出：2
解释：我们最多可以放两块骨牌：[[0, 0], [0, 1]]以及[[0, 2], [1, 2]]。（见下图）

 

示例 2：

输入：n = 3, m = 3, broken = []
输出：4
解释：下图是其中一种可行的摆放方式

 

限制：

1 <= n <= 8
1 <= m <= 8
0 <= b <= n * m

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/broken-board-dominoes
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

[aaaaaabiao]

容易理解的回溯解法

class Solution {
    
    private int max = 0;
    private int tmp = 0;
    //使用回溯法把所有情况都列出来
    public int domino(int n, int m, int[][] broken) {
        //构建一个二维数组。data[][]。
        //data[i][j] == 0：代表(i,j)位置可以放置牌
        //data[i][j] == 1：代表(i,j)位置已经放置过了
        //data[i][j] == -1：代表(i,j)位置坏掉了
        
        int[][] data = new int[n][m];
        
        for(int i = 0; i < broken.length; i++) {
            int x = broken[i][0];
            int y = broken[i][1];
            
            data[x][y] = -1;
        }
        
        backtracing(data, 0, 0);
        return max;
        
    }
    
    
    
    public void backtracing(int[][] data, int row, int col) {
        
        int lx = data.length;
        int ly = data[0].length;
        
        //row超过index，回溯终止，计算max
        if(row >= lx) {
            max = Math.max(max, tmp);
            return;
        }
        
        //col超过index,换行，继续回溯
        if(col >= ly) {
            backtracing(data, row+1, 0);
            return;
        }
        
        //当前节点坏了或不能放置跳过该节点
        if(data[row][col] == -1 || data[row][col] == 1) {
            backtracing(data, row, col+1);
            return;
        }
        
        //横着放
        boolean h = false;
        if(col + 1 < ly && data[row][col+1] == 0) {
            h = true;
            data[row][col] = 1;
            data[row][col+1] = 1;
            tmp++;
            backtracing(data, row, col+2);
            data[row][col] = 0;
            data[row][col+1] = 0;
            tmp--;
        }
        
        //竖着放
        boolean v = false;
        if(row + 1 < lx && data[row+1][col] == 0) {
            v = true;
            data[row][col] = 1;
            data[row+1][col] = 1;
            tmp++;
            backtracing(data, row, col+1);
            data[row][col] = 0;
            data[row+1][col] = 0;
            tmp--;
        }
        
        //横竖都不能放时,跳两格
        if(!h && !v) {
            backtracing(data, row, col+2);
        }
    }
}

[stale]

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.