n天后的牢房

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]

提示：

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

看到题目第一眼就是利用循环去解决，判断一个数左右两边是否满足条件，这种方法简单易懂，但是当N较大的时候，计算时间会超时。

def prisonafterndays(cells,n):
    import copy
    k=len(cells)
    while n>=0:
        temp = copy.deepcopy(cells)
        # print(temp)
        for i in range(1,k-1):
            if (temp[i-1]==0 and temp[i+1]==0) or (temp[i-1]==1 and temp[i+1]==1):
                cells[i]=1
            else:
                cells[i]=0
        cells[len(cells)-1]=0
        # print(temp)
        n-=1
    return temp

于是，我们就应该换一种角度去思考问题，上面的一种方法是站在cells内元素的角度，我们还可以从牢房的状态去思考，无论是第几天，牢房的状态最多只有2^6种可能，将每次出现的状态进行编码（num*2.num+1）和保存,如果某一状态出现第二次，那么接下来的状态就会在这两个状态之间循环，根据剩余的循环次数对总的状态进行取余就可以得到答案。

def prisonAfterNDays( cells, N):
    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
        # print(num)
        if num not in state:
            state.append(num)
            cell.append(newcells)
            cells = newcells
        else:
            # print(len(state),state.index(num))
            # print(state)
            step = len(state) - state.index(num)
            laststep = N - 1 - i
            k = laststep % step
            return cell[state.index(num) + k]
    return cells