[LeetCode] 957. Prison Cells After N Days

There are 8 prison cells in a row, and each cell is either occupied or vacant.

Each day, whether the cell is occupied or vacant changes according to the following rules:

• If a cell has two adjacent neighbors that are both occupied or both vacant, then the cell becomes occupied.
• Otherwise, it becomes vacant.

(Note that because the prison is a row, the first and the last cells in the row can't have two adjacent neighbors.)

We describe the current state of the prison in the following way: cells[i] == 1 if the i-th cell is occupied, else cells[i] == 0.

Given the initial state of the prison, return the state of the prison after N days (and N such changes described above.)

Example 1:

Input: cells = [0,1,0,1,1,0,0,1], N = 7
Output: [0,0,1,1,0,0,0,0]
Explanation: 
The following table summarizes the state of the prison on each day:
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]

Example 2:

Input: cells = [1,0,0,1,0,0,1,0], N = 1000000000
Output: [0,0,1,1,1,1,1,0]

Note:

1. cells.length == 8
2. cells[i] is in {0, 1}
3. 1 <= N <= 10^9

N天后的牢房。

8 间牢房排成一排，每间牢房不是有人住就是空着。每天，无论牢房是被占用或空置，都会根据以下规则进行更改：

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

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

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/prison-cells-after-n-days
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

暴力解不难想，但是由于N有可能非常大，所以需要找规律。为什么一定有规律呢，因为8个牢房，每个牢房的状态只有0和1，所以最坏也就只有2^8 = 256种组合。如果N大于256，则一定有循环。

首先创建一个nextDay函数，计算下一天的牢房状态；其次需要一个hashset，记录是否有重复的状态，记得在Java里需要把数组转化成字符串再存入hashset。当找到循环次数之后可以立即停止，然后用N % 循环次数。

时间O(1) - 最多255次计算

空间O(n) - hashset

Java实现

class Solution {
    public int[] prisonAfterNDays(int[] cells, int N) {
        // corner case
        if (cells == null || cells.length == 0 || N <= 0) {
            return cells;
        }

        // normal case
        boolean hasCycle = false;
        int cycle = 0;
        HashSet<String> set = new HashSet<>();
        for (int i = 0; i < N; i++) {
            int[] next = nextDay(cells);
            String key = Arrays.toString(next);
            if (!set.contains(key)) {
                set.add(key);
                cycle++;
            } else {
                hasCycle = true;
                break;
            }
            cells = next;
        }
        if (hasCycle) {
            N %= cycle;
            for (int i = 0; i < N; i++) {
                cells = nextDay(cells);
            }
        }
        return cells;
    }

    private int[] nextDay(int[] cells) {
        int[] temp = new int[cells.length];
        for (int i = 1; i < cells.length - 1; i++) {
            temp[i] = cells[i - 1] == cells[i + 1] ? 1 : 0;
        }
        return temp;
    }
}

JavaScript实现

/**
 * @param {number[]} cells
 * @param {number} N
 * @return {number[]}
 */
var prisonAfterNDays = function (cells, N) {
    var list = [];
    var num = N;
    for (var j = 1; j <= N; j++) {
        var arr = [];
        for (var i = 0; i < cells.length; i++) {
            if (i == 0 || i == cells.length - 1) {
                arr[i] = 0;
            } else {
                if (cells[i - 1] == cells[i + 1]) {
                    arr[i] = 1;
                } else {
                    arr[i] = 0;
                }
            }
        }
        list.push(arr); // 存放数组,直到找到周期值
        cells = arr;
        if (j > 1 && arr.join('') == list[0].join('')) {
            // console.log(j)
            // console.log(arr)  15=1  16=2   找出周期关系
            num = j - 1; // 获取周期
            break;
        }
    }
    var n = N % num; // 周期内的位置
    if (n == 0) {
        return list[num - 1];
    } else {
        return list[n - 1];
    }
};

LeetCode 题目总结