算法每日一题:参加考试的最大学生数 | 动态规划 | 状态压缩

大家好,我是星恒
今天的题目竟然是一道困难题目,看着就不简单,我们的目标是:理解如何做 + 学一些思路!
这次题目涉及的知识:动态规划,状态压缩(位运算)

给你一个 m * n 的矩阵 seats 表示教室中的座位分布。如果座位是坏的(不可用),就用 ‘#’ 表示;否则,用 ‘.’ 表示。学生可以看到左侧、右侧、左上、右上这四个方向上紧邻他的学生的答卷,但是看不到直接坐在他前面或者后面的学生的答卷。请你计算并返回该考场可以容纳的同时参加考试且无法作弊的 **最大 **学生人数。
学生必须坐在状况良好的座位上。

示例 1:
算法每日一题:参加考试的最大学生数 | 动态规划 | 状态压缩_第1张图片

输入:seats = [["#",".","#","#",".","#"],
              [".","#","#","#","#","."],
              ["#",".","#","#",".","#"]]
输出:4
解释:教师可以让 4 个学生坐在可用的座位上,这样他们就无法在考试中作弊。

示例 2:

输入:seats = [[".","#"],
              ["#","#"],
              ["#","."],
              ["#","#"],
              [".","#"]]
输出:3
解释:让所有学生坐在可用的座位上。

示例 3:

输入:seats = [["#",".",".",".","#"],
              [".","#",".","#","."],
              [".",".","#",".","."],
              [".","#",".","#","."],
              ["#",".",".",".","#"]]
输出:10
解释:让学生坐在第 1、3 和 5 列的可用座位上。

提示:

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

分析:
这道困难题,我们先说一下总体思路,然后再讨论为什么这样做:
首先,我们说一下数据的存储

  • 用 m 表示行数,n 表示列数
  • 使用0,1(0 好座位,1 坏座位)来表示一排的情况,并使用二进制表示法表示这种情况,一共n位
  • 使用dp[m][2n]来存储答案可能的所有情况的人数,1 …2n表示一排可能出现的所有情况(因为这样可以将所有情况的二进制数表示了出来)

好啦,现在我们就可以正式开始这道题

  • 遍历每一行,并将符号转化为二进制数字
    • 遍历这一行坐人每一种情况
      • 这样坐人,是否有人做到了坏凳子上
      • 这样坐人,是否有相邻的人做到了旁边
      • 这样坐人,是否有前面一排的人相邻
        • 遍历寻找可行的前排可行情况,判断左上和右上是否有人
        • 如果这些条件都满足,我们看这种可行前排情况下,和其他前排可行情况哪个大,我们选最大的那个
      • 求得了当前可行情况下的最佳坐的人数(这里是前面所有人的人数)
    • 这里就求的了这一排所有情况下,每一种情况的最佳坐人人数
  • 遍历dp[m][2n]的最后一排,求他们的最大值

题解:

class Solution {
    public int maxStudents(char[][] seats) {
        final int m = seats.length, n = seats[0].length;
        
        int[][] dp = new int[m + 1][1 << n];
        for (int i = 1; i <= m; i++) {
            int invalid = 0;
            for (int j = 0; j < n; j++) {
                if (seats[i - 1][j] == '#') {
                    invalid |= 1 << j;
                }
            }
            
            for (int j = 0; j < (1 << n); j++) {
                int adjacentMask = j << 1;
                if ((j & invalid) != 0 || (j & adjacentMask) != 0) {
                    dp[i][j] = -1;
                    continue;
                }
                
                int theOtherAdjacentMask = j >> 1;           
                for (int s = 0; s < (1 << n); s++) {
                    if (dp[i - 1][s] == -1) {
                        continue;
                    }
                    if ((s & adjacentMask) != 0 || (s & theOtherAdjacentMask) != 0) {
                        continue;
                    }
                    dp[i][j] = Math.max(dp[i][j], dp[i - 1][s] + Integer.bitCount(j));
                }
            }
        }
        
        int max = 0;
        for (int i = 0; i < 1 << n; i++) {
            max = Math.max(max, dp[m][i]);
        }
        
        return max;        
    }
}

你可能感兴趣的:(算法,动态规划)