GAME OF LIFE

最优解：

class Solution {
private:
    int dis[8][2] = {{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0},{-1,1}};
public:
    void gameOfLife(vector<vector<int>>& board) {

        //把0,1转化为四种状态的一种
        for(int i = 0;i < board.size();i++) {
            for(int j = 0;j < board[0].size();j++) {
                int cnt = 0;
                for(int k = 0;k < 8;k++) {
                    if(isOne(board,i + dis[k][0],j + dis[k][1]))  ++cnt;
                }
                if(board[i][j]) {
                    if(cnt < 2 || cnt > 3)     board[i][j] = 1;
                    else    board[i][j] = 3;
                }
                else if(cnt == 3)
                    board[i][j] = 2;
            }
        }

        //转换成答案,即下一次的结果
        for(int i = 0;i < board.size();i++) {
            for(int j = 0;j < board[0].size();j++) {
                if(board[i][j] <= 1)    board[i][j] = 0;
                else    board[i][j] = 1;
            }
        }
    }

    //判断这个点当前是不是活的
    bool isOne(vector<vector<int>>& board,int i,int j) {
        if(i >= 0 && i < board.size() && j >= 0 && j < board[0].size()
           && (board[i][j] == 1 || board[i][j] == 3))  return true;
        return false;
    }
};

这个是别人的代码。效率比我第一次写的较高，请做详细分析。

MY CODE:

class Solution {
public:
    int MAX_N,MAX_M;
    void gameOfLife(vector<vector<int>>& board) {

        int m = 0;//一行m个
        int n = 0;//n行
        MAX_N = board.size()-1;
        if (MAX_N < 0)
            return;
        MAX_M = board[0].size()-1;
        if (MAX_M < 0)
            return;

        vector<vector<int>> vec_out = board;
        for (n = 0;n <= MAX_N;n++)
        {
            for (m = 0;m <= MAX_M;m++)
            {
                int num = neighbors_num(board, m, n);
                if (board[n][m] == 1)
                {
                    if (num <= 1)
                        vec_out[n][m] = 0;
                    else if (num <= 3)
                        vec_out[n][m] = 1;
                    else
                        vec_out[n][m] = 0;
                }
                else
                {
                    if (num == 3)
                        vec_out[n][m] = 1;
                }
            }
        }
        board = vec_out;
    }
    int neighbors_num(vector<vector<int>>& board, int m, int n){
        /*
        n-1,m-1   n-1,m   n-1,m+1
        n,m-1      n,m    n,m+1
        n+1,m-1    n+1,m   n+1,m+1
        */
        /*
        n=0&&m=0
        */
        int num = 0;
        int x, y;
        for ( x = n - 1;x <= n + 1;x++)
            for ( y = m - 1;y <= m + 1;y++)
            {
                if (x<0 || x>MAX_N || y<0 || y>MAX_M)
                    continue;
                else if (x == n && y == m)
                    continue;
                else
                    num = board[x][y] + num;

            }
        return num;
    }
};

分析结果：
由于容器之间赋值耗时较长，故直接使用原容器，用不同位数表示当前和下一步状态。

class Solution {
public:
    int SIZE_Y, SIZE_X;
    void gameOfLife(vector<vector<int>>& board) {
        //若为空退出
        SIZE_Y = board.size();
        if (SIZE_Y < 0)
            return;
        SIZE_X = board[0].size();
        if (SIZE_X < 0)
            return;
        show(board);

        //遍历计算
        for (int y = 0;y < SIZE_Y;y++)
        {
            for (int x = 0;x < SIZE_X;x++)
            {
                int num = neighbors_num(board, y, x);//取其活邻居个数
                if (board[y][x] == 1)
                {
                    if (num <= 1)
                        board[y][x] = 01;
                    else if (num <= 3)
                        board[y][x] = 11;
                    else
                        board[y][x] = 01;
                }
                else
                {
                    if (num == 3)
                        board[y][x] = 10;
                    else
                        board[y][x] = 00;
                }
            }
        }

        for (int y = 0;y < SIZE_Y;y++)
        {
            for (int x = 0;x < SIZE_X;x++)
            {
                board[y][x] = board[y][x] / 10;
            }
        }
        show(board);
    }
    int neighbors_num(vector<vector<int>>& board, int Y, int X) {
        /*
        n-1,m-1   n-1,m   n-1,m+1
        n,m-1      n,m    n,m+1
        n+1,m-1    n+1,m   n+1,m+1
        */
        /*
        n=0&&m=0
        */
        int num = 0;
        for (int y = Y - 1;y <= Y + 1;y++)
            for (int x = X - 1;x <= X + 1;x++)
            {
                if (x < 0 || x >= SIZE_X || y < 0 || y >= SIZE_Y)
                    continue;
                else if (x == X && y == Y)
                    continue;
                else
                    num = board[y][x]%10 + num;

            }
        return num;
    }

    void show(vector<vector<int>>& board)
    {
        cout << "________________________________new" << endl;
        for (int y = 0;y < SIZE_Y;y++)
        {
            for (int x = 0;x < SIZE_X;x++)
            {
                if (board[y][x] == 1)
                    cout << "◆";
                else
                    cout << "◇";
            }
            cout << endl;
        }
    }
};

效率最高。