2019 力扣杯全国秋季编程大赛：4. 覆盖（状压DP）

4. 覆盖

 显示英文描述 

我的提交

• 用户通过次数66
• 用户尝试次数269
• 通过次数67
• 提交次数788
• 题目难度Hard

你有一块棋盘，棋盘上有一些格子已经坏掉了。你还有无穷块大小为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. 1 <= n <= 8
2. 1 <= m <= 8
3. 0 <= b <= n * m

思路：典型的状压DP，因为n和m不超过8，也就是说每一行的状态不会超过256

我们设dp[i][j]：表示第i行状态为j时能放的最多的多米诺骨牌，我们要时刻记得当前行的状态所能得到的最大值可能会存在来自于上一行的影响的（因为我们的多米诺骨牌可以竖着放）！！！

class Solution {
    public int domino(int n, int m, int[][] broken) {
        int[] a=new int[10];
        int[][] dp=new int[10][256];
        int[] o=new int[256];
        int ans=0;
        
        for(int i=0;i<broken.length;i++)
        {
        	int x=broken[i][0];
        	int y=broken[i][1];
        	
        	a[x]|=1<<y;
        }
        
        for(int i=0;i<10;i++)
        	for(int j=0;j<256;j++)
        		dp[i][j]=0;
        dp[0][(1<<m)-1]=0;
        for(int i=1;i<(1<<m);i++)
        	o[i]=o[i>>1]+(i&1);
        for(int i=0;i<n;i++)
        {
        	for(int j=0;j<(1<<m);j++)
        		dp[i+1][0]=Math.max(dp[i+1][0], dp[i][j]);
        	if(i>0)
        	{
        		for(int j=0;j<(1<<m);j++)
        			for(int k=0;k<(1<<m);k++)
        			{
        				 if((j&k)==0 && (a[i-1]&k)==0 && (a[i]&k)==0)
        					 dp[i+1][k]=Math.max(dp[i+1][k],dp[i][j]+o[k]);
        			}
        	}
        	for(int j=0;j+1<m;j++)
        	{
        		if((a[i]>>j&1)==0 && (a[i]>>j+1&1)==0)
        		{
        			for(int k=0;k<(1<<m);k++)
        			{
        				if((k>>j&1)==0 && (k>>j+1&1)==0)
        					dp[i+1][k|1<<j|1<<j+1]=Math.max(dp[i+1][k|1<<j|1<<j+1],dp[i+1][k]+1);
        			}
        		}
        	}
        }
        for(int i=0;i<(1<<m);i++)
        	ans=Math.max(ans, dp[n][i]);
        return ans;
    }
}