2026-05-28：树上的勾股距离节点。用go语言，给定一棵包含 n 个节点的无向树（节点编号为 0 到 n-1），树的边用长度为 n-1 的数组 edges

package main

import (
    "fmt"
    "slices"
)

func specialNodes(n int, edges [][]int, x, y, z int) (ans int) {
    g := make([][]int, n)
    for _, e := range edges {
        v, w := e[0], e[1]
        g[v] = append(g[v], w)
        g[w] = append(g[w], v)
    }

    calcDis := func(start int) []int {
        dis := make([]int, n)
        var dfs func(int, int)
        dfs = func(v, fa int) {
            for _, w := range g[v] {
                if w != fa {
                    dis[w] = dis[v] + 1
                    dfs(w, v)
                }
            }
        }
        dfs(start, -1)
        return dis
    }

    dx := calcDis(x)
    dy := calcDis(y)
    dz := calcDis(z)

    for i := range n {
        a := []int{dx[i], dy[i], dz[i]}
        slices.Sort(a)
        if a[0]*a[0]+a[1]*a[1] == a[2]*a[2] {
            ans++
        }
    }
    return
}

func main() {
    n := 4
    edges := [][]int{{0, 1}, {0, 2}, {0, 3}}
    x := 1
    y := 2
    z := 3
    result := specialNodes(n, edges, x, y, z)
    fmt.Println(result)
}

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

from typing import List

def specialNodes(n: int, edges: List[List[int]], x: int, y: int, z: int) -> int:
    # 构建邻接表
    g = [[] for _ in range(n)]
    for v, w in edges:
        g[v].append(w)
        g[w].append(v)

    # 计算从 start 出发到所有节点的距离
    def calcDis(start: int) -> List[int]:
        dis = [0] * n
        visited = [False] * n
        
        def dfs(v: int):
            visited[v] = True
            for w in g[v]:
                if not visited[w]:
                    dis[w] = dis[v] + 1
                    dfs(w)
        
        dfs(start)
        return dis

    dx = calcDis(x)
    dy = calcDis(y)
    dz = calcDis(z)

    ans = 0
    for i in range(n):
        a = [dx[i], dy[i], dz[i]]
        a.sort()
        if a[0] * a[0] + a[1] * a[1] == a[2] * a[2]:
            ans += 1
    
    return ans


def main():
    n = 4
    edges = [[0, 1], [0, 2], [0, 3]]
    x = 1
    y = 2
    z = 3
    result = specialNodes(n, edges, x, y, z)
    print(result)


if __name__ == "__main__":
    main()

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>

using namespace std;

int specialNodes(int n, vector<vector<int>>& edges, int x, int y, int z) {
    // 构建邻接表
    vector<vector<int>> g(n);
    for (auto& e : edges) {
        int v = e[0], w = e[1];
        g[v].push_back(w);
        g[w].push_back(v);
    }

    // 计算从 start 出发到所有节点的距离
    auto calcDis = [&](int start) -> vector<int> {
        vector<int> dis(n, 0);

        // DFS 函数声明
        function<void(int, int)> dfs = [&](int v, int fa) {
            for (int w : g[v]) {
                if (w != fa) {
                    dis[w] = dis[v] + 1;
                    dfs(w, v);
                }
            }
        };

        dfs(start, -1);
        return dis;
    };

    vector<int> dx = calcDis(x);
    vector<int> dy = calcDis(y);
    vector<int> dz = calcDis(z);

    int ans = 0;
    for (int i = 0; i < n; i++) {
        vector<int> a = {dx[i], dy[i], dz[i]};
        sort(a.begin(), a.end());
        if (a[0] * a[0] + a[1] * a[1] == a[2] * a[2]) {
            ans++;
        }
    }

    return ans;
}

int main() {
    int n = 4;
    vector<vector<int>> edges = {{0, 1}, {0, 2}, {0, 3}};
    int x = 1, y = 2, z = 3;

    int result = specialNodes(n, edges, x, y, z);
    cout << result << endl;

    return0;
}