2026-07-28：统计每个顶点的度。用go语言，给你一个 n x n 的二维整数数组，它代表一个无向图的邻接矩阵，包含 n 个编号从 0 到 n-1 的顶点

2026-07-28：统计每个顶点的度。用go语言，给你一个 n x n 的二维整数数组，它代表一个无向图的邻接矩阵，包含 n 个编号从 0 到 n-1 的顶点。

矩阵中的值表示两个顶点之间是否有边：1 表示相连，0 表示不相连。一个顶点的度是指和它相连的边的总数。

请你计算并返回一个长度为 n 的数组，其中第 i 个位置存放顶点 i 的度数。

1 <= n == matrix.length == matrix[i].length <= 100。

matrix[i][i] == 0。

matrix[i][j] 仅为 0 或 1。

matrix[i][j] == matrix[j][i]。

在这里插入图片描述

输入： matrix = [[0,1,1],[1,0,1],[1,1,0]]。

输出： [2,2,2]。

解释：

顶点 0 与顶点 1 和 2 相连，因此其度为 2。

顶点 1 与顶点 0 和 2 相连，因此其度为 2。

顶点 2 与顶点 0 和 1 相连，因此其度为 2。

因此，答案为 [2, 2, 2]。

题目来自力扣3898。

第一步：理解输入结构

输入是一个 n x n 的二维整数数组 matrix，代表一个无向图的邻接矩阵。
题目保证了以下几点：

矩阵是方阵，即 len(matrix) 等于 len(matrix[i])。
对角线元素 matrix[i][i] 都为 0，表示没有自环。
矩阵是对称的，即 matrix[i][j] == matrix[j][i]，满足无向图的性质。
每个元素只能是 0 或 1，1 表示顶点 i 和 j 之间有一条边，0 表示没有边。

第二步：确定任务目标

我们要返回一个长度为 n 的数组 ans，其中 ans[i] 是顶点 i 的度数。
度数的定义是：与该顶点直接相连的边的条数。
因为是无向图，一条边连接两个顶点，在度数统计中会被两个端点各自计数一次。

第三步：初始化结果数组

函数 findDegrees 接收矩阵后，首先用 make([]int, len(matrix)) 创建一个与顶点数量相同长度的整数切片 ans，此时所有元素默认值为 0。
这个切片将用来累加每个顶点的边数。

第四步：按行遍历，累加度数

代码的外层循环使用 for i, row := range matrix 遍历矩阵的每一行：

变量 i 是当前顶点编号，取值从 0 到 n-1。
变量 row 是第 i 行的整行数据，它也是一个切片，长度等于 n。

对于每一行 row，内层循环用 for _, x := range row 遍历该行的每一个元素 x：

由于矩阵只包含 0 和 1，x 的值要么是 0（无边），要么是 1（有边）。
直接将 x 加到 ans[i] 上：ans[i] += x。

这样，对于顶点 i，会把它所在的整行（即顶点 i 与其他所有顶点 j 的连接情况）上的 1 全部累加。
因为矩阵是对称的，这一行有多少个 1，就代表顶点 i 与多少个其他顶点相连，也就是顶点 i 的度数。

第五步：返回结果

当外层循环结束，所有顶点的度数都已累加完毕，函数直接返回填充好的 ans 切片。

第六步：主函数调用与输出

在 main 函数中，定义了一个 3x3 的示例矩阵，对应一个三角形无向图（每个顶点都与另外两个相连），然后调用 findDegrees 得到结果 [2, 2, 2]，最后打印出来。

复杂度分析

时间复杂度：

外层循环执行 n 次，内层循环对每行同样执行 n 次，总共访问矩阵的每一个元素恰好一次。
对每个元素只做一次累加操作，常数时间。
所以总的时间复杂度是 O(n²)。

额外空间复杂度：

除了输入矩阵本身占用的空间（不计入额外空间），算法只创建了一个长度为 n 的结果数组 ans。
没有使用其他与 n 相关的辅助数据结构。
因此，总的额外空间复杂度是 O(n)。

总结：
该算法通过遍历邻接矩阵的每一行，累加每行的值来得到每个顶点的度数，过程简单直接，时间复杂度 O(n²)，额外空间复杂度 O(n)。

Go完整代码如下：

package main

import (
	"fmt"
)

func findDegrees(matrix [][]int) []int {
	ans := make([]int, len(matrix))
	for i, row := range matrix {
		for _, x := range row {
			ans[i] += x
		}
	}
	return ans
}

func main() {
	matrix := [][]int{{0, 1, 1}, {1, 0, 1}, {1, 1, 0}}
	result := findDegrees(matrix)
	fmt.Println(result)
}

在这里插入图片描述

Python完整代码如下：

# -*-coding:utf-8-*-

from typing import List

def find_degrees(matrix: List[List[int]]) -> List[int]:
    ans = [0] * len(matrix)
    for i, row in enumerate(matrix):
        ans[i] = sum(row)
    return ans

if __name__ == "__main__":
    matrix = [[0, 1, 1], [1, 0, 1], [1, 1, 0]]
    result = find_degrees(matrix)
    print(result)

在这里插入图片描述

C++完整代码如下：

#include <iostream>
#include <vector>

std::vector<int> findDegrees(const std::vector<std::vector<int>>& matrix) {
    std::vector<int> ans(matrix.size(), 0);
    for (size_t i = 0; i < matrix.size(); ++i) {
        for (int x : matrix[i]) {
            ans[i] += x;
        }
    }
    return ans;
}

int main() {
    std::vector<std::vector<int>> matrix = {
        {0, 1, 1},
        {1, 0, 1},
        {1, 1, 0}
    };
    std::vector<int> result = findDegrees(matrix);

    std::cout << "[";
    for (size_t i = 0; i < result.size(); ++i) {
        std::cout << result[i];
        if (i != result.size() - 1) std::cout << ", ";
    }
    std::cout << "]" << std::endl;

    return 0;
}

在这里插入图片描述