思路是枚举BC之后从可到达位置中选择前几个进行计算。如果只选择前3个就只有45分，有WA和TLE。如果选择前14个就有80分，只剩一个WA其余都是TLE。

#include <queue>
#include <vector>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

const size_t maxn = 2500, maxm = 1e4;

struct Node
{
    bool toHome;
    vector<size_t> Side;
    long long val;
    void AddSide(size_t target){
        Side.push_back(target);
    }
    Node(){
        toHome = false;
        val = -1;
    }
} Map[maxn + 5];
vector<size_t> achievable[maxn + 5];

using sizePair = pair<size_t, int>;

int isVisited[maxn + 5];

inline bool cmp(const size_t &a, const size_t &b){
    return Map[a].val > Map[b].val;
}

inline void bfs(int pos, int n, int k)
{
    memset(isVisited, 0, sizeof(int) * (n + 1));
    queue<sizePair> que;
    que.push(sizePair(pos, -1));
    while (que.size()){
        // 将可以访问的压入并对当前位置记录
        auto cur = que.front();que.pop();
        isVisited[cur.first] = 1;
        for (auto next : Map[cur.first].Side){
            sizePair tmp(next, cur.second + 1);
            if (tmp.second > k)continue;
            if (isVisited[next])continue;
            que.push(tmp);
        }
        if (cur.first != pos)
            achievable[pos].push_back(cur.first);
    }
    if (pos == 1)sort(achievable[pos].begin(), achievable[pos].end());
    else sort(achievable[pos].begin(), achievable[pos].end(), cmp);
}
int main()
{
    int n, m, k;
    cin >> n >> m >> k;
    for (int i = 2; i <= n; i++)cin >> Map[i].val;
    for (int j = 0; j < m; j++)
    {
        int x, y;
        cin >> x >> y;
        Map[x].AddSide(y);
        Map[y].AddSide(x);
    }
    long long ans = 0;
    auto getVal = [&](size_t p) -> long long
    {
        return Map[p].val;
    };
    for (int i = 1; i <= n; i++)
        pre_dfs(i, n, k);
    for (auto i : achievable[1])
        Map[i].toHome = true;
    for (size_t b = 2; b <= n; b++)

    {
        for (size_t c : achievable[b])
        {
            if (c == 1)
                continue;
            for (size_t i = 0; i < 3 && i < achievable[b].size(); i++)
            {
                for (size_t j = 0; j < 3 && j < achievable[c].size(); j++)
                {
                    size_t a = achievable[b][i];
                    size_t d = achievable[c][j];
                    if (a == b || a == c || a == d)
                        continue;
                    if (d == b || d == c || a == d)
                        continue;
                    // AD连到家
                    if (!Map[a].toHome || !Map[d].toHome)
                        continue;
                    long long tmp = getVal(a) + getVal(b) + getVal(c) + getVal(d);
                    ans = max(ans, tmp);
                }
            }
        }
    }
    cout << ans;
    return 0;
}