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

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++完整代码如下：

  

  



 std::vector findDegrees(const 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 
 
 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 
 ; 
 
 
 }