• [LC] 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]

    Brute Force -> LTE
    class Solution {
        public int[] prisonAfterNDays(int[] cells, int N) {
            int[][] arr = new int[N + 1][cells.length];
            for (int i = 0; i < cells.length; i++) {
                arr[0][i] = cells[i];
            }
            for (int i = 1; i <= N; i++) {
                for (int j = 0; j < cells.length; j++) {
                    if (j == 0 || j == cells.length - 1) {
                        continue;
                    }
                    if (arr[i - 1][j - 1] == 0 && arr[i - 1][j + 1] == 0 || arr[i - 1][j - 1] == 1 && arr[i - 1][j + 1] == 1) {
                        arr[i][j] = 1;
                    }
                }
                // System.out.println(i + ": " + Arrays.toString(arr[i]));
            }
            return arr[N];
        }
    }

    solution: find there is cycle form

    class Solution {
        public int[] prisonAfterNDays(int[] cells, int N) {
            Set<String> set = new HashSet<>();
            boolean hasCycle = false;
            int count = 0;
            int[] nxt = new int[cells.length];
            for (int i = 0; i < N; i++) {
                nxt = getNext(cells);
                String str = Arrays.toString(nxt);
                if (set.contains(str)) {
                    hasCycle = true;
                    break;
                } else {
                    set.add(str);
                    count += 1;
                }
                cells = nxt;
            }
            if (hasCycle) {
                N = N % count;
                for (int i = 0; i < N; i++) {
                    cells = getNext(cells);
                }
            }
            return cells;
        }
        
        private int[] getNext(int[] cells) {
            int[] arr = new int[cells.length];
            for (int i = 1; i < cells.length - 1; i++) {
               arr[i] = cells[i - 1] == cells[i + 1] ? 1 : 0; 
            }
            return arr;
        }
    }
  • 相关阅读:
    机器学习读书笔记(六)
    机器学习读书笔记(五)AdaBoost
    机器学习读书笔记(三)决策树基础篇之从相亲说起
    机器学习读书笔记(四)朴素贝叶斯基础篇之网站账号分类
    机器学习读书笔记(二)使用k-近邻算法改进约会网站的配对效果
    机器学习读书笔记(一)k-近邻算法
    大数据集群常见问题总结
    Hadoop、Hbase基本命令及调优方式
    Java多线程优化方法及使用方式
    Linux-RED HAT6.8扩容
  • 原文地址:https://www.cnblogs.com/xuanlu/p/12702783.html
Copyright © 2020-2023  润新知