---

---

1572. 矩阵对角线元素的和：

给你一个正方形矩阵 mat，请你返回矩阵对角线元素的和。

请你返回在矩阵主对角线上的元素和副对角线上且不在主对角线上元素的和。

样例 1：

输入：
	mat = [[1,2,3],
	       [4,5,6],
	       [7,8,9]]
            
输出：
	25
	
解释：
	对角线的和为：1 + 5 + 9 + 3 + 7 = 25
	请注意，元素 mat[1][1] = 5 只会被计算一次。
1
2
3
4
5
6
7
8
9
10
11

样例 2：

输入：
	mat = [[1,1,1,1],
           [1,1,1,1],
           [1,1,1,1],
           [1,1,1,1]]
	            
输出：
	8
1
2
3
4
5
6
7
8

样例 3：

输入：
	mat = [[5]]
	
输出：
	5
1
2
3
4
5

提示：

• n == mat.length == mat[i].length
• 1 <= n <= 100
• 1 <= mat[i][j] <= 100

---

分析

• 面对这道算法题目，二当家的陷入了沉思。
• 如果不思考，直接按照题意照做，那么直观的做法就是从左上角遍历到右下角，再从右上角遍历到左下角，同时判断奇数中心点，不要重复加。
• 其实也可以按行遍历一次，每行添加2个数，中心点的问题，可以在循环中判断，但是要做n次判断，不如在遍历完之后，判断如果是奇数，减去重复的中心点即可。

---

题解

rust

impl Solution {
    pub fn diagonal_sum(mat: Vec<Vec<i32>>) -> i32 {
        let n = mat.len();

        let mut ans = mat.iter().enumerate().map(|(r, row)| {
            row[r] + row[n - 1 - r]
        }).sum();

        if n & 1 == 1 {
            ans -= mat[n / 2][n / 2];
        }

        ans
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---

go

func diagonalSum(mat [][]int) int {
    ans := 0

	n := len(mat)
	for r, row := range mat {
		ans += row[r] + row[n-1-r]
	}

	if n&1 == 1 {
		ans -= mat[n/2][n/2]
	}

	return ans
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

---

typescript

function diagonalSum(mat: number[][]): number {
    let ans = 0;

	const n = mat.length;

	for (let r = 0; r < mat.length; ++r) {
		ans += mat[r][r] + mat[r][n - 1 - r];
	}

	if ((n & 1) == 1) {
		ans -= mat[Math.floor(n / 2)][Math.floor(n / 2)];
	}

	return ans;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---

python

class Solution:
    def diagonalSum(self, mat: List[List[int]]) -> int:
        ans = 0
        n = len(mat)
        for r in range(n):
            ans += mat[r][r] + mat[r][n - 1 - r]
        if n & 1 == 1:
            ans -= mat[n // 2][n // 2]
        return ans

1
2
3
4
5
6
7
8
9
10

---

c

int diagonalSum(int** mat, int matSize, int* matColSize){
    int ans = 0;
    for (int r = 0; r < matSize; ++r) {
        ans += mat[r][r] + mat[r][matSize - 1 - r];
    }
    if (matSize & 1 == 1) {
        ans -= mat[matSize / 2][matSize / 2];
    }
    return ans;
}
1
2
3
4
5
6
7
8
9
10

---

c++

class Solution {
public:
    int diagonalSum(vector<vector<int>>& mat) {
        int ans = 0;
        const int n = mat.size();
        for (int r = 0; r < n; ++r) {
            ans += mat[r][r] + mat[r][n - 1 - r];
        }
        if (n & 1 == 1) {
            ans -= mat[n / 2][n / 2];
        }
        return ans;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

---

java

class Solution {
    public int diagonalSum(int[][] mat) {
        int ans = 0;

        int n = mat.length;

        for (int r = 0; r < n; ++r) {
            ans += mat[r][r];
            ans += mat[r][n - 1 - r];
        }

        if ((n & 1) == 1) {
            ans -= mat[n / 2][n / 2];
        }

        return ans;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

---

原题传送门：https://leetcode.cn/problems/matrix-diagonal-sum/

---

非常感谢你阅读本文~
欢迎【点赞】【收藏】【评论】~
放弃不难，但坚持一定很酷~
希望我们大家都能每天进步一点点~
本文由 二当家的白帽子：https://le-yi.blog.csdn.net/ 博客原创~

---