矩阵操作

根据百度百科，生命游戏，简称为生命，是英国数学家约翰·何顿·康威在1970年发明的细胞自动机。

给定一个包含 m × n 个格子的面板，每一个格子都可以看成是一个细胞。每个细胞具有一个初始状态 live（1）即为活细胞， 或 dead（0）即为死细胞。每个细胞与其八个相邻位置（水平，垂直，对角线）的细胞都遵循以下四条生存定律：

如果活细胞周围八个位置的活细胞数少于两个，则该位置活细胞死亡；
如果活细胞周围八个位置有两个或三个活细胞，则该位置活细胞仍然存活；
如果活细胞周围八个位置有超过三个活细胞，则该位置活细胞死亡；
如果死细胞周围正好有三个活细胞，则该位置死细胞复活；
根据当前状态，写一个函数来计算面板上细胞的下一个（一次更新后的）状态。下一个状态是通过将上述规则同时应用于当前状态下的每个细胞所形成的，其中细胞的出生和死亡是同时发生的。

示例:

输入:
[
[0,1,0],
[0,0,1],
[1,1,1],
[0,0,0]
]
输出:
[
[0,0,0],
[1,0,1],
[0,1,1],
[0,1,0]
]

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

enum {
    DEAD = 0,
    LIVE = 1,

    NEXT = 0,
    CURR = 4,
    UPDATE = 8,

};

int g_stateTran[2][9] = {
    { DEAD, DEAD, DEAD, LIVE, DEAD, DEAD, DEAD, DEAD, DEAD },  // dead Trans, 只有周围有三个活细胞才复活
    { DEAD, DEAD, LIVE, LIVE, DEAD, DEAD, DEAD, DEAD, DEAD }  // live Trans, 只有周围有两个或三个活细胞才保持live
};

int g_raw, g_col;
int countNeighborLive(int **board, int x, int y)
{
    int count = 0;
    for (int i = x - 1; i <= x + 1; ++i) {  // (i, j) < (x, y) 的都是更新了的
        for (int j = y - 1; j <= y + 1; ++j) {
            if (i < 0 || j < 0 || i >= g_raw || j >= g_col || i == x && j == y) {
                continue;
            }
            if (board[i][j] & (1 << UPDATE)) {
                count += (board[i][j] >> CURR) & 1;
            } else {
                count += board[i][j];
            }
        }
    }

    return count;
}

void gameOfLife(int **board, int boardSize, int *boardColSize)
{
    if (!board || boardSize == 0 || !boardColSize || *boardColSize == 0) {
        return;
    }
    g_raw = boardSize;
    g_col = *boardColSize;
    
    int currState, nextState;
    int count;
    for (int row = 0; row < boardSize; ++row) {
        for (int col = 0; col < *boardColSize; ++col) {
            currState = board[row][col];
            if (currState != DEAD && currState != LIVE) {
                printf("data Err.\n");
                return;
            }
            count = countNeighborLive(board, row, col);
            nextState = g_stateTran[currState][count];
            board[row][col] = 1 << UPDATE | currState << CURR | nextState;
        }
    }

    for (int row = 0; row < boardSize; ++row) {
        for (int col = 0; col < *boardColSize; ++col) {
            board[row][col] &= (1 << CURR) - 1;
        }
    }
    return;
}

2. 你的面前有一堵方形的、由多行砖块组成的砖墙。 这些砖块高度相同但是宽度不同。你现在要画一条自顶向下的、穿过最少砖块的垂线。

砖墙由行的列表表示。 每一行都是一个代表从左至右每块砖的宽度的整数列表。

如果你画的线只是从砖块的边缘经过，就不算穿过这块砖。你需要找出怎样画才能使这条线穿过的砖块数量最少，并且返回穿过的砖块数量。

你不能沿着墙的两个垂直边缘之一画线，这样显然是没有穿过一块砖的。

示例：

输入: [[1,2,2,1],
[3,1,2],
[1,3,2],
[2,4],
[3,1,2],
[1,3,1,1]]

输出: 2

解释:

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

int g_currMin;
int g_row;

void ThroughInEveryRow(int **wall, int *wallColSize, int currRow)
{
    int Offset;
    int count = 0;
    int isThrough;
    for (int colInCurrRow = 0; colInCurrRow < *(wallColSize + currRow) - 1; ++colInCurrRow) {
        Offset = *(*(wall + currRow) + colInCurrRow);
        count = 0;
        // 查找
        // 逐行遍历
        for (int row = 0; row < g_row; ++row) {
            if (row == currRow) {
                continue;
            }
            isThrough = 1;
            // 一行逐列遍历Offset
            for (int col = 0; col < *(wallColSize + row) - 1; ++col) {
                if (Offset == *(*(wall + row) + col)) {
                    isThrough = 0;
                    break;
                }
                if (Offset < *(*(wall + row) + col)) {
                    break;
                }
            }

            count += isThrough;

            if (count >= g_currMin) {  // 剪枝，如果前几行已经大于当前找到的最小值，就不在遍历剩下的行
                break;
            }
        }
        g_currMin = count < g_currMin ? count : g_currMin;
    }
}

int leastBricks(int **wall, int wallSize, int *wallColSize)
{
    if (!wall || wallSize == 0 || !wallColSize) {
        return 0;
    }
    g_row = wallSize;
    // 1.  将长度转化为Offset
    int offset;
    for (int row = 0; row < wallSize; ++row) {
        offset = 0;
        for (int col = 0; col < *(wallColSize + row); ++col) {
            offset += *(*(wall + row) + col);
            *(*(wall + row) + col) = offset;
        }
    }
    // 2.  根据Offset判断有无穿过砖
    g_currMin = wallSize;
    for (int row = 0; row < wallSize; ++row) {
        ThroughInEveryRow(wall, wallColSize, row);
    }

    return g_currMin;
}

int main()
{
    int wall1[] = { 1, 2, 2, 1 };
    int wall2[] = { 3, 1, 2 };
    int wall3[] = { 1, 3, 2 };
    int wall4[] = { 2, 4 };
    int wall5[] = { 3, 1, 2 };
    int wall6[] = { 1, 3, 1, 1 };

    int *wall[] = {
        wall1,
        wall2,
        wall3,
        wall4,
        wall5,
        wall6
    };

    int len[] = { 4, 3, 3, 2, 3, 4 };
    int wallSize = 6;

    int res = leastBricks((int **)wall, wallSize, len);
    return 0;
}