Leetcode 957. N 天后的牢房

最新推荐文章于 2020-11-25 22:42:14 发布

StormButterfly

最新推荐文章于 2020-11-25 22:42:14 发布

阅读量579

点赞数

CC 4.0 BY-SA版权

分类专栏： python leetcode

本文链接：https://blog.youkuaiyun.com/weixin_43891542/article/details/85054202

leetcode 同时被 2 个专栏收录

2 篇文章

订阅专栏

python

1 篇文章

订阅专栏

本文介绍了一种监狱状态模拟问题，通过编码保存每次状态变化，利用循环特性解决大规模天数预测问题。详细解析了算法思路和代码实现，展示了如何高效处理状态循环。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

8 间牢房排成一排，每间牢房不是有人住就是空着。

每天，无论牢房是被占用或空置，都会根据以下规则进行更改：

如果一间牢房的两个相邻的房间都被占用或都是空的，那么该牢房就会被占用。
否则，它就会被空置。

（请注意，由于监狱中的牢房排成一行，所以行中的第一个和最后一个房间无法有两个相邻的房间。）

我们用以下方式描述监狱的当前状态：如果第 i 间牢房被占用，则 cell[i]==1，否则 cell[i]==0。

根据监狱的初始状态，在 N 天后返回监狱的状况（和上述 N 种变化）。

示例 1：

输入：cells = [0,1,0,1,1,0,0,1], N = 7
输出：[0,0,1,1,0,0,0,0]
解释：
下表概述了监狱每天的状况：
Day 0: [0, 1, 0, 1, 1, 0, 0, 1]
Day 1: [0, 1, 1, 0, 0, 0, 0, 0]
Day 2: [0, 0, 0, 0, 1, 1, 1, 0]
Day 3: [0, 1, 1, 0, 0, 1, 0, 0]
Day 4: [0, 0, 0, 0, 0, 1, 0, 0]
Day 5: [0, 1, 1, 1, 0, 1, 0, 0]
Day 6: [0, 0, 1, 0, 1, 1, 0, 0]
Day 7: [0, 0, 1, 1, 0, 0, 0, 0]

示例 2：

输入：cells = [1,0,0,1,0,0,1,0], N = 1000000000
输出：[0,0,1,1,1,1,1,0]

提示：

cells.length == 8
cells[i] 的值为 0 或 1
1 <= N <= 10^9

思路：

最简单的是按照规则循环，然而时间超出限制。我们从另外一个角度看待问题，无论状态怎么变化，最多只有 $2^{6}$ 种可能，我们将每次出现的状态进行编码并保存。如果某一次的状态出现第二次，那么接下来状态将会在两次状态中循环，根据抽屉原理，最多 $2^{6}$ + 1 次后就会出现循环，接下来根据还剩余的循环次数取余即可。

代码：

class Solution:
    def prisonAfterNDays(self, cells, N):
        """
        :type cells: List[int]
        :type N: int
        :rtype: List[int]
        """
        state = []
        cell = []
        for i in range(N):
            num = 0
            newcells = [0] * 8
            for j in range(1, 7):
                if cells[j - 1] == cells[j + 1]:
                    num *= 2
                    num += 1
                    newcells[j] = 1
                else:
                    num *= 2
                    newcells[j] = 0
            if num not in state:
                state.append(num)
                cell.append(newcells)
                cells = newcells
            else:
                step = len(state) - state.index(num)
                laststep = N - 1 - i
                k = laststep % step
                return cell[state.index(num) + k]
        return cells

对于上述代码还可以进行优化，为了编程的方便，我只是简单编码，用了一个列表来储存状态，完全可以通过解码的方式还原，这样节约了一部分空间和时间。同时，对于数组的更新使用了另外一个数组，完全可以通过原地修改实现更新。