七月集训day11矩阵

1975. 最大方阵和

代码/思路

思路：
1- 如果负数的个数为偶数，则一定可以把所有元素变为正数，累加即可得到答案
2- 如果负数的个数为奇数，那么会剩余一个负数，先把所有数变为正数，然后把最小的数变为负数，累加即可得到答案

class Solution {
public:
    long long maxMatrixSum(vector<vector<int>>& matrix) {
        int n = matrix.size();
        int flag = 0;
        long long sum = 0;
        vector<int> neg;
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < n; j++)
            {
                if(matrix[i][j] < 0)
                {
                    neg.push_back(matrix[i][j]);
                }
                else if(matrix[i][j] > 0)
                {
                    sum += matrix[i][j];
                }
                else
                {
                    flag = 1;
                }
                
            }
        }

        if(flag || neg.size() % 2 == 0)
        {
            for(int i = 0; i < neg.size(); i++)
            {
                sum += -neg[i];
            }
        }
        else
        {
            neg.clear();
            sum = 0;
            for(int i = 0; i < n; i++)
            {
                for(int j = 0; j < n; j++)
                {
                    if(matrix[i][j] < 0)
                    {
                        matrix[i][j] = -matrix[i][j];
                    }
                    neg.push_back(matrix[i][j]);
                    sum += matrix[i][j];
                }
            }
            sort(neg.begin(), neg.end());
            sum += -2 * neg[0];
        }
        return sum;
    }
};

840. 矩阵中的幻方

代码/思路

思路：
1.直接模拟
(1）枚举矩阵中的任意一个格子作为3x3矩阵的起点;
(2）判断对应3x3矩阵，是否满足如下两个条件:
1、行列对角线的和是否等于第一行的和;
2、利用哈希表判断3x3矩阵是否由1-9组成;一旦满足这两个条件返回1;否则返回0。

class Solution {
    int check(vector<vector<int>>& grid, int x, int y)
    {
        //第一行元素的和
        int sum = grid[x][y] + grid[x][y + 1] + grid[x][y + 2];

        for(int i = 0; i < 3; i++)
        {
            //第一到三列的和
            if(sum != grid[x][y + i] + grid[x + 1][y + i] + grid[x + 2][y + i])
            {
                return 0;
            }
            //第一到三行的和
            if(sum != grid[x + i][y] + grid[x + i][y + 1] + grid[x + i][y + 2])
            {
                return 0;
            }
        }
        //正对角线的和
        if(sum != grid[x][y] + grid[x + 1][y + 1] + grid[x + 2][y + 2])
        {
            return 0;
        }
        //副对角线的和
        if(sum != grid[x + 2][y] + grid[x + 1][y + 1] + grid[x][y + 2])
        {
            return 0;
        }
        //用hash表判断是否当前矩阵是否是幻方
        int hash[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
        for(int i = 0; i < 3; i++)
        {
            for(int j = 0; j < 3; j++)
            {
                //数字在0-9之间
                if(grid[x + i][y + j] > 9 || grid[x + i][y + j] == 0)
                {
                    return 0;
                }
                //数字只能出现一次
                if(++hash[grid[x + i][y + j]] > 1)
                {
                    return 0;
                }
            }
        }
        return 1;
    }
public:
    int numMagicSquaresInside(vector<vector<int>>& grid) {
        int ans = 0;
        int r = grid.size();
        int c = grid[0].size();
        for(int i = 0; i < r - 2; i++)
        {
            for(int j = 0; j < c - 2; j++)
            {
                ans += check(grid, i, j);
            }
        }
        return ans;
    }
};