LC Weekly Contest 86_840&841

840. 矩阵中的幻方

3 x 3 的幻方是一个填充有从 1 到 9 的不同数字的 3 x 3 矩阵，其中每行，每列以及两条对角线上的各数之和都相等。
给定一个由整数组成的 grid，其中有多少个 3 × 3 的 “幻方” 子矩阵？（每个子矩阵都是连续的）。

示例：

输入: [[4,3,8,4],
      [9,5,1,9],
      [2,7,6,2]]
输出: 1

解释:
下面的子矩阵是一个 3 x 3 的幻方：

438
951
276

而这一个不是：

384
519
762

总的来说，在本示例所给定的矩阵中只有一个 3 x 3 的幻方子矩阵。

提示:
1 <= grid.length <= 10
1 <= grid[0].length <= 10
0 <= grid[i][j] <= 15

class Solution {
public:
    
    bool isMagicSquares(vector<vector<int>>& grid, int x, int y)
    {
        vector<bool> flag(10, false); 
        for(int dx = 0; dx < 3; dx++)
        {
            int row_val = 0;
            int col_val = 0;
            for(int dy = 0; dy < 3; dy++)
            {
                int val = grid[x + dx][y + dy];
                flag[val] = true;
                row_val += grid[x + dx][y + dy];
                col_val += grid[x + dy][y + dx];
            }
            if(row_val != 15 || col_val != 15)
                return false;
        }
        //对角线
        if(grid[x][y] + grid[x + 1][y + 1] + grid[x + 2][y + 2] != 15)
            return false;
        if(grid[x + 2][y] + grid[x + 1][y + 1] + grid[x][y + 2] != 15)
            return false;
        
        for(int i = 1; i <= 9; i++) //1 到 9 个数字
            if(!flag[i])
                return false;
        return true;
    }
    
    int numMagicSquaresInside(vector<vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();        
        if(m < 3 || n < 3)
            return 0;
        else
        {            
            int res = 0;
            for(int i = 0; i < m - 2; i++)
                for(int j = 0; j < n - 2; j ++)
                {
                    if(isMagicSquares(grid, i, j))
                        res ++;
                }
            return res;
        }        
    }
};

841. 钥匙和房间

有 N 个房间，开始时你位于 0 号房间。每个房间有不同的号码：0，1，2，…，N-1，并且房间里可能有一些钥匙能使你进入下一个房间。

在形式上，对于每个房间 i 都有一个钥匙列表 rooms[i]，每个钥匙 rooms[i][j] 由 [0,1，…，N-1] 中的一个整数表示，其中 N = rooms.length。 钥匙 rooms[i][j] = v 可以打开编号为 v 的房间。

最初，除 0 号房间外的其余所有房间都被锁住。

你可以自由地在房间之间来回走动。

如果能进入每个房间返回 true，否则返回 false。

示例 1：

输入: [[1],[2],[3],[]]
输出: true
解释:
我们从 0 号房间开始，拿到钥匙 1。
之后我们去 1 号房间，拿到钥匙 2。
然后我们去 2 号房间，拿到钥匙 3。
最后我们去了 3 号房间。
由于我们能够进入每个房间，我们返回 true。

示例 2：

输入：[[1,3],[3,0,1],[2],[0]]
输出：false
解释：我们不能进入 2 号房间。

提示：
1 <= rooms.length <= 1000
0 <= rooms[i].length <= 1000
所有房间中的钥匙数量总计不超过 3000。

注意审题: 可以自由地在房间之间来回走动

class Solution {
public:
    bool canVisitAllRooms(vector<vector<int>>& rooms) {
        int n = rooms.size();
        vector<int> vis(n, 0); //一开始初始化所有房间不能打开
        vis[0] = 1; //0号房间可以打开
        DFS(0, rooms, vis);
        for(int i = 0; i < n; i++) 
            if(vis[i] == 0)
                return false;
        return true;
    }
    
    void DFS(int m, vector<vector<int>>& rooms, vector<int>& vis)
    {
        for(int i = 0; i < rooms[m].size(); i ++) //遍历第二层
            if(vis[rooms[m][i]] == 0)
            {
                vis[rooms[m][i]] = 1;                  
                DFS(rooms[m][i], rooms, vis);
            }
    }
};