• 289. Game of Life


    package LeetCode_289
    
    /**
     * 289. Game of Life
     * https://leetcode.com/problems/game-of-life/
     * According to the Wikipedia's article:
     * "The Game of Life, also known simply as Life, is a cellular automaton devised by the British mathematician John Horton Conway in 1970."
    Given a board with m by n cells, each cell has an initial state live (1) or dead (0).
    Each cell interacts with its eight neighbors (horizontal, vertical, diagonal) using the following four rules (taken from the above Wikipedia article):
    1. Any live cell with fewer than two live neighbors dies, as if caused by under-population.
    2. Any live cell with two or three live neighbors lives on to the next generation.
    3. Any live cell with more than three live neighbors dies, as if by over-population.
    4. Any dead cell with exactly three live neighbors becomes a live cell, as if by reproduction.
    Write a function to compute the next state (after one update) of the board given its current state.
    The next state is created by applying the above rules simultaneously to every cell in the current state, where births and deaths occur simultaneously.
    Example:
    Input:
    [
    [0,1,0],
    [0,0,1],
    [1,1,1],
    [0,0,0]
    ]
    Output:
    [
    [0,0,0],
    [1,0,1],
    [0,1,1],
    [0,1,0]
    ]
     * */
    class Solution {
        /*
        * solution: simulation, scan board:
        * 1. if need set die to live, mark current position to -1,
        * 2. if need set live to die, mark current position to 2,
        * Time: O(m*n), Space: O(1)
        * */
        val directions = arrayOf(
            //x,y
            intArrayOf(0, 1),//up
            intArrayOf(1, 0),//right
            intArrayOf(0, -1),//down
            intArrayOf(-1, 0),//left
            intArrayOf(-1, 1),//up,left
            intArrayOf(1, 1),//up,right
            intArrayOf(-1, -1),//down,left
            intArrayOf(1, -1)//down,right
        )
    
        fun gameOfLife(board: Array<IntArray>): Unit {
            val m = board.size
            val n = board[0].size
            for (i in 0 until m) {
                for (j in 0 until n) {
                    //need set to live: Any dead cell with exactly three live neighbors becomes a live cell
                    if (board[i][j] == 0) {
                        val liveCount = countLive(board, i, j)
                        if (liveCount == 3) {
                            board[i][j] = -1
                        }
                    }
                    //need set to die:
                    //1. Any live cell with more than three live neighbors dies
                    //2. Any live cell with fewer than two live neighbors dies
                    if (board[i][j] == 1) {
                        val liveCount = countLive(board, i, j)
                        if (liveCount > 3 || liveCount < 2) {
                            board[i][j] = 2
                        }
                    }
                }
            }
            update(board)
        }
    
        private fun countLive(board: Array<IntArray>, x: Int, y: Int): Int {
            var count = 0
            for (dir in directions) {
                val newX = x + dir[0]
                val newY = y + dir[1]
                if (newX < 0 || newY < 0 || newX >= board.size || newY >= board[0].size) {
                    continue
                }
                if (board[newX][newY] == 1 || board[newX][newY] == 2) {
                    count++
                }
            }
            return count
        }
    
        private fun update(board: Array<IntArray>) {
            val m = board.size
            val n = board[0].size
            for (i in 0 until m) {
                for (j in 0 until n) {
                    if (board[i][j] == -1) {
                        board[i][j] = 1
                    }
                    if (board[i][j] == 2) {
                        board[i][j] = 0
                    }
                }
            }
        }
    }
  • 相关阅读:
    mysql存储过程及拼接字符串的用法
    SpringMVC的工作原理
    3年java工作经验必备技能
    HashMap的源码,实现原理,底层结构
    十年软件测试感悟,写给想要转行的测试新人。
    软件自动化测试有了测试工程师就等于有了质量?
    为何你的简历石沉大海?这份新鲜出炉的测试用人需求分析报告揭示了原因。
    【软件测试】Python自动化软件测试算是程序员吗?
    达内教育培训怎么样,值得去吗?
    软件测试员最核心的竞争力究竟是什么? 爱码小哥
  • 原文地址:https://www.cnblogs.com/johnnyzhao/p/14155084.html
Copyright © 2020-2023  润新知