矩阵对角线元素的和 图解题解

对角线求和，到底要加哪些格子

给一个 n 行 n 列的正方形矩阵 mat，把它两条对角线上的元素加起来。主对角线是从左上角到右下角那条，副对角线是从右上角到左下角那条。题面例子是第一行 1、2、3，第二行 4、5、6，第三行 7、8、9 的方阵，答案 25；再小到 mat 只有一个数 5，答案就是 5。要留神两条对角线在正方形中间可能落到同一个格子上，题目要的是这个格子只算一次的和。

两条判定式，直接点到对角线上的格子

对角线上满打满算才 2n 个元素，把整张 n 乘 n 的表挨个格子扫一遍再挑，其余全是陪跑。好在对角线元素的位置有现成判定式：给一个格子记行号 i 和列号 j，它在主对角线上，当且仅当 i 等于 j；在副对角线上，当且仅当 i 加 j 等于 n 减 1。按行走，第 i 行里主对角线那格落在第 i 列，副对角线那格落在第 n 减 1 减 i 列，一步定位。唯一要当心两格会不会重合：当第 n 减 1 减 i 列正好等于第 i 列时，两条对角线在这行撞到一起，那格正是正方形的正中心，只有 n 是奇数才会发生，它在主对角线那趟已经加过，副对角线这趟就得跳过。

一趟循环，顺手把去重也做了

参考代码把它压成一趟循环。累加变量 ans 从零起，按行遍历：对第 i 行，先加上主对角线元素、即第 i 列的值；再令 j 等于 n 减 1 减 i，若 j 不等于 i，就把第 j 列的副对角线元素也加上；若 j 等于 i，说明撞上正中心、已经加过，直接跳过。走完 n 行，ans 就是答案，求和与去重一次遍历全办了。

拿题面这个 3 乘 3 矩阵手算一遍

还是第一行 1、2、3、第二行 4、5、6、第三行 7、8、9 这个矩阵，n 是 3。先走主对角线：第 0 行取 1，第 1 行取 5，第 2 行取 9，和是 1 加 5 加 9 等于 15。再走副对角线，n 减 1 是 2：第 0 行取第 2 列的 3；第 1 行副对角线列 n 减 1 减 1 还是第 1 列，和主对角线撞在一起、落在正中心 5，跳过不加；第 2 行取第 0 列的 7。

合起来 15 加 3 加 7 等于 25，正中心的 5 只算一次，和题面答案对得上。要是忘了去重、把中心的 5 再加一遍，就会从 25 错成 30，这是本题最常见的失分点。

偶数边长别多减，单格矩阵就是它自己

先说奇偶这道坎。n 是奇数时两条对角线在正中心交叉，那格必须去重；可 n 是偶数时，正中心落在四个格子正当中、不落到任何具体格子，两条线一个公共格都没有，八格各加一次，这时再减中心反而把答案算小了。副对角线下标是 j 等于 n 减 1 减 i，少减那个 1、写成 j 等于 n 减 i，整条对角线都会错位甚至越界。最小的边界是单格矩阵，n 是 1，那个数既在主对角线又在副对角线正中心上，只算一次，答案就是它本身，也就是题面第二个例子里那个 5。

复杂度上，全程按行走一遍、每行最多看两个格子，最多 2n 个、跟边长成正比，时间 O(n)，不必扫整张 n 乘 n 的表；空间上只用一个累加变量，空间 O(1)。

Python

from __future__ import annotations
from typing import *
from collections import *
from functools import *
from itertools import *
from math import *
from heapq import *
from bisect import *
class Solution:
    def diagonalSum(self, mat: List[List[int]]) -> int:
        ans = 0
        n = len(mat)
        for i, row in enumerate(mat):
            j = n - i - 1
            ans += row[i] + (0 if j == i else row[j])
        return ans

C++

#include <algorithm>
#include <array>
#include <cctype>
#include <climits>
#include <cmath>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
class Solution {
public:
    int diagonalSum(vector<vector<int>>& mat) {
        int ans = 0;
        int n = mat.size();
        for (int i = 0; i < n; ++i) {
            int j = n - i - 1;
            ans += mat[i][i] + (i == j ? 0 : mat[i][j]);
        }
        return ans;
    }
};

Java

import java.util.*;
class Solution {
    public int diagonalSum(int[][] mat) {
        int ans = 0;
        int n = mat.length;
        for (int i = 0; i < n; ++i) {
            int j = n - i - 1;
            ans += mat[i][i] + (i == j ? 0 : mat[i][j]);
        }
        return ans;
    }
}