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

class Solution {
public:
    # 假设 0ghijkl0 由 0abcdef0 变化得到，那么由g可以知道b，由l可以知道e
    # 由e和j可以知道c，由b和i可以知道d，由h和c可以知道a，由k和d可以知道f
    # 所以形如 0abcdef0 的一组数，唯一对应上一组数，因此如果有循环出现，那么必定会重复第一天的那组数
    vector<int> prisonAfterNDays(vector<int>& cells, int N) {
        vector<string> v;
        string first; // 先得到第一天的那组数
        for(int i=0;i<8;i++)
        {
            if(i==0||i==7) first.push_back('0');
            else if(cells[i-1]==cells[i+1]) first.push_back('1');
            else first.push_back('0');
        }
        v.push_back(first);
        
        string pre=first;
        string cur=first;
        for(int i=1;i<N;i++)
        {
            for(int j=0;j<8;j++)
            {
                if(j==0||j==7) cur[j]='0';
                else if(pre[j-1]==pre[j+1]) cur[j]='1';
                else cur[j]='0';
            }
            
            if(cur==first) //找到了循环
            {
                if(N%v.size()==0) N=v.size()-1;
                else N=N%v.size()-1;
                cur=v[N];
                break;
            }
            v.push_back(cur);
            pre=cur;
        }
        
        vector<int> result;
        for(auto c:cur) result.push_back(c-'0');
        return result;
    }
};