1349. 参加考试的最大学生数

1349. 参加考试的最大学生数

1349. 参加考试的最大学生数

难度： 困难

题目大意：

给你一个 m * n 的矩阵 seats 表示教室中的座位分布。如果座位是坏的（不可用），就用 '#' 表示；否则，用 '.' 表示。

学生可以看到左侧、右侧、左上、右上这四个方向上紧邻他的学生的答卷，但是看不到直接坐在他前面或者后面的学生的答卷。请你计算并返回该考场可以容纳的同时参加考试且无法作弊的 最大 学生人数。

学生必须坐在状况良好的座位上。

提示：

• seats 只包含字符 '.' 和``'#'
• m == seats.length
• n == seats[i].length
• 1 <= m <= 8
• 1 <= n <= 8

根据题目的意思和数据范围可大概知道这题的思路 : 状态压缩dp

状态压缩DP, 记忆化搜索，位运算

• 状态压缩

  注意到，每一个位置有两种情况，有人坐和无人坐 可以用一个数的二进制位表示某一行的状态，比如0100101，所有1都表示这个位置坐一个人，所有0都表示这个位置没有人坐， 每一行的状态会受到上一行的状态的影响，那么当前这一行就可以从上一行的某个状态转移过来，当然并不是每一个状态都是有效的，以某一行为例，如果1在'#'的位置，显然是不合理的，还有如果(i, j)是1那么他的(i, j - 1), (i, j + 1)的位置不能是1，另一种情况是两行之间的不合理，比如说(i, j)是1那么(i - 1, j + 1)``(i - 1, j - 1)不能是1

• 位运算

  怎么判断一个二进制某一个位置是不是1呢？ 这里就要学习一个很常见的位运算技巧

  // 判断n的第i个二进制位是不是1
  if (n >> i & 1) ...
  

  // 得到一个数的二进制的最右端的二进制1，具体可以在草稿纸上验证一下
  int lowbit(int n) {
      return n & -n; // -n取得的是n的补码
  }
  // 那么我们就可以根据这一特点可以得到一个数中的二进制位1的个数了
  int count1 (int n) {
      int res = 0;
      for (int i = n; i ; i -= lowbit(i)) { res ++; }
      return res;
  }
  

代码实现

class Solution {
public:
    int maxStudents(vector<vector<char>>& seats) {
        // 状态压缩dp
         int n = seats.size(), m = seats[0].size();
         unordered_map<int, int> st;
         
         // 判断当前行的状态的合理性
         auto rowValid = [&](int row, int status) -> bool {
            for (int i = 0; i < m; i ++) {
                if (status >> i & 1) {
                    if (seats[row][i] == '#') 
                        return false;
                    if (i > 0 && (status >> (i - 1)) & 1) 
                        return false;
                }
             }
             return true;
         };
		//判断当前行的状态和上一个状态的合理性
         auto upperValid = [&](int nowStatus, int upperStatus) -> bool  {
             for (int i = 0; i < m; i ++) {
                if ((nowStatus >> i) & 1) {
                    if (i > 0 && ((upperStatus >> (i - 1)) & 1))
                        return false;
                    if (i + 1 < m && (upperStatus >> (i + 1)) & 1) 
                        return false;
                 }
             }
             return true;
        };
		// 计算 n 的二进制位中 1 的个数
        auto count1 = [&](int n) -> int {
            int res = 0;
            while (n) {
                res ++;
                n -= n & -n; // lowbit, 减去 n 的最右端的 1
            }
            return res;
        };
		// 记忆化搜索
        function<int(int, int)> dfs = [&](int row, int status) -> int {
            // 这个是表示每一行每一个状态的, row << m 记录第几行，status表示这一行的状态信息
            int key = (row << m) + status; 
            if (!st.count(key)) {
                if (!rowValid(row, status)) {
                    st[key] = INT32_MIN; // 记忆化这个状态，表示这个状态是不行的
                    return INT32_MIN;      
                }
                int sum = count1(status);
                if (row == 0) { // 递归终点
                    st[key] = sum;
                    return sum;
                }
                int res = 0;
                // 枚举上一层的每一个状态，如果合理就 dfs
                for (int i = 0; i < 1 << m; i ++) {
                    if (upperValid(status, i)) {
                        res = max(res, dfs(row - 1, i));
                    }
                }
                st[key] = sum + res; // 记忆化
            }
            return st[key]; // 返回当前状态的学生数量和上一层的学生数量
        };
       
        int res = 0;
        // 枚举每一个状态，取一个max，最终就能得到结果
        for (int i = 0; i < 1 << m; i ++) {
            res = max(res, dfs(n - 1, i));
        }
        return res;
    }
};

时间复杂度： $O(mn$2^{2m}$)$

结束了!