[题解]我才是 Joker

$$\color{red}{\text{校长者，真神人也，左马桶，右永神，会执利笔破邪炁，何人当之？}} \\ \begin{array}{|} \hline \color{pink}{\text{The principal is really a god}} \\ \color{pink}{\text{with a closestool on the left and Yongshen on the right}} \\ \color{pink}{\text{holding a sharp pen to pierce the truth}} \\ \color{pink}{\text{Who can resist him? }} \\ \hline \end{array} \\ \begin{array}{|} \hline \color{green}{\text{校長は本当に神であり、左側にトイレ、右側にヨンシェンがあり}} \\ \color{green}{\text{鋭いペンを持って真実を突き刺している。誰が彼に抵抗できるだろうか？ }} \\ \hline \end{array} \\ \begin{array}{|} \hline \color{lightblue}{\text{Le principal est vraiment un dieu}} \\ \color{lightblue}{\text{avec des toilettes à gauche et Yongshen à droite}} \\ \color{lightblue}{\text{tenant un stylo pointu pour percer la vérité}} \\ \color{lightblue}{\text{Qui peut lui résister ? }} \\ \hline \end{array} \\ \begin{array}{|} \hline \color{purple}{\text{Der Direktor ist wirklich ein Gott}} \\ \color{purple}{\text{mit einer Toilette links und Yongshen rechts}} \\ \color{purple}{\text{der einen spitzen Stift hält}} \\ \color{purple}{\text{um die Wahrheit zu durchdringen.}} \\ \color{purple}{\text{Wer kann ihm widerstehen? }} \\ \hline \end{array} \\ \begin{array}{|} \hline \color{cyan}{\text{Principalis deus est, Yongshen a dextris cum latrina}} \\ \color{cyan}{\text{acuto stylo ad perforandum veritatem: quis resistet ei? }} \\ \hline \end{array} \\ \color{red}{\text{对曰：“无人，狗欲当之，还请赐教！”}} \\ \newcommand\brak[1]{\left({#1}\right)} \newcommand\Brak[1]{\left\{{#1}\right\}} \newcommand\d[0]{\text{d}} \newcommand\string[2]{\genfrac{\{}{\}}{0pt}{}{#1}{#2}} \newcommand\down[2]{{#1}^{\underline{#2}}} \newcommand\ddiv[2]{\left\lfloor\frac{#1}{#2}\right\rfloor} \newcommand\udiv[2]{\left\lceil\frac{#1}{#2}\right\rceil} \newcommand\lcm[0]{\operatorname{lcm}} \newcommand\set[1]{\left\{{#1}\right\}} \newcommand\ceil[1]{\left\lceil{#1}\right\rceil} \newcommand\floor[1]{\left\lfloor{#1}\right\rfloor} \newcommand\rhs[1]{\;\text{Rhs}\;#1} \newcommand\lhs[1]{\;\text{Lhs}\;#1} \newcommand\Vec[1]{\vec{\mathbf{#1}}} \newcommand\rank[0]{\text{rank}}$$

  $\mathcal{Back\;To\;The\;Menu}$.

2022-03-15 我才是 Joker

  真没想到 T1 的 $\mathcal O(n^5)$ 跑得这么快，预估是可能在常数上有一个 $\displaystyle \frac{1}{16}$ 的缘故。另外 T3 还没有补，着实想不通了。

梦批糼 / Dream

  我也不会念这个题目的名字。

  其实我们的目标就是算出包含每个格子的合法的长方体的个数，最暴力的方法是 $\mathcal O(n^9)$，花费 $\mathcal O(n^6)$ 代价枚举矩形，再用 $\mathcal O(n^3)$ 枚举矩形中每一个元素算贡献。这种方法用高维前缀和优化就可以降为 $\mathcal O(n^6)$，还是有点距离。

  如果我们将枚举的目标换成一个点，显然也不好，因为基础复杂度就是 $\mathcal O(n^3)$，再加上一些统计的实现，可能就变成 $\mathcal O(n^6)$ ，但是，如果我们将枚举一个点变成枚举一个面？显然基础复杂度是 $\mathcal O(n^4)$ 的，但是我们只需要 $\mathcal O(n)$ 去扫一遍这个面所对应的所有合法的极长柱就行了，对于极长柱的每一层，用一个差分来 $\mathcal O(1)$ 记录答案即可。

  因此总复杂度是 $\mathcal O(n^5)$ 的，但是常数上有一个 $\displaystyle \frac{1}{4}$，这可能也是它可以过的原因。

/** @author __Elaina__ */

// #pragma GCC optimize("Ofast")

#include <bits/stdc++.h>
using namespace std;

#define USING_FREAD
// #define NDEBUG
#include <cassert>

namespace Elaina {
/** その可憐な少女は魔女であり、旅人でした。 ―― そう、私です! */

#define rep(i, l, r) for(int i = (l), i##_end_ = (r); i <= i##_end_; ++i)
#define repf(i, l, r) for (int i = (l), i##_end_ = (r); i < i##_end_; ++i)
#define drep(i, l, r) for(int i = (l), i##_end_ = (r); i >= i##_end_; --i)
#define fi first
#define se second
#define mp(a, b) make_pair(a, b)
#define Endl putchar('\n')
#define whole(v) ((v).begin()), ((v).end())
#define bitcnt(s) (__builtin_popcount(s))
/** @warning no forced type conversion */
#define rqr(x) ((x) * (x))
#define y0 FUCK_UP
#define y1 MOTHER_FUCKER
#define masdf(...) fprintf(stderr, __VA_ARGS__)

typedef long long ll;
typedef unsigned long long ull;
typedef std::pair<int, int> pii;
typedef vector<int> vset;

template<class T> inline T fab(T x) { return x < 0 ? -x : x; }
template<class T> inline void chkmin(T& x, const T rhs) { x = std::min(x, rhs); }
template<class T> inline void chkmax(T& x, const T rhs) { x = std::max(x, rhs); }

#ifdef USING_FREAD
inline char qkgetc() {
# define BUFFERSIZE 1 << 20
    static char BUF[BUFFERSIZE], *p1 = BUF, *p2 = BUF;
    return p1 == p2 && (p2 = (p1 = BUF) + fread(BUF, 1, BUFFERSIZE, stdin), p1 == p2) ? EOF : *p1++;
# undef BUFFERSIZE
}
# define CHARRECEI qkgetc()
#else
# define CHARRECEI getchar()
#endif

template<class T> inline T readret(T x) {
    x = 0; int f = 0; char c;
    while (!isdigit(c = CHARRECEI)) if(c == '-') f = 1;
    for (x = (c ^ 48); isdigit(c = CHARRECEI); x = (x << 1) + (x << 3) + (c ^ 48));
    return f ? -x : x;
}
template<class T> inline void readin(T& x) {;
    x = 0; int f = 0; char c;
    while (!isdigit(c = CHARRECEI)) if (c == '-') f = 1;
    for (x = (c ^ 48); isdigit(c = CHARRECEI); x = (x << 1) + (x << 3) + (c ^ 48));
    if (f) x = -x;
}
template<class T, class... Args> inline void readin(T& x, Args&... args) {
    readin(x), readin(args...);
}
template<class T> inline void writln(T x, char c = '\n') {
    if (x < 0) putchar('-'), x = -x;
    static int __stk[55], __bit = 0;
    do __stk[++__bit] = x % 10, x /= 10; while (x);
    while (__bit) putchar(__stk[__bit--] ^ 48);
    putchar(c);
}

} // namespace Elaina
using namespace Elaina;

#define int long long

const int Maxn = 60;
const int mod = 998244353;
inline void chkadd(int& x, int y) { if ((x += y) >= mod) x -= mod; }

inline int qkpow(int a, int q) {
    int p = 1;
    for (; q; q >>= 1, a = 1ll * a * a % mod)
        if (q & 1) p = 1ll * p * a % mod;
    return p;
}

int n, m, r, q, u;
int cnt[Maxn + 5][Maxn + 5][Maxn + 5];
int val[Maxn + 5][Maxn + 5][Maxn + 5];

inline void input() {
    readin(n, m, r, q);
    u = (1ll * n * (n + 1) * m * (m + 1) * r * (r + 1) / 8) % mod;
    rep (i, 1, n) rep (j, 1, m) rep (k, 1, r)
        readin(cnt[i][j][k]), cnt[i][j][k] ^= 1;
    rep (i, 1, n) rep (j, 1, m) rep (k, 1, r)
        readin(val[i][j][k]);
}

inline void prelude() {
    rep (k, 1, r) rep (i, 1, n) rep (j, 1, m)
        cnt[i][j][k] += cnt[i - 1][j][k] + cnt[i][j - 1][k] - cnt[i - 1][j - 1][k];
}

int buc[Maxn + 5];
int ans[Maxn + 5][Maxn + 5][Maxn + 5], valid = 0;
inline void solve() {
    rep (lx, 1, n) rep (rx, lx, n) rep (ly, 1, m) rep (ry, ly, m) {
        rep (i, 1, r) buc[i] = cnt[rx][ry][i]
          - cnt[lx - 1][ry][i] - cnt[rx][ly - 1][i]
          + cnt[lx - 1][ly - 1][i];
        // masdf("Now lx == %d, rx == %d, ly == %d, ry == %d\n", lx, rx, ly, ry);
        for (int i = 1, j = 1; i <= r; i = ++j) if (!buc[i]) {
            while (j < r && !buc[j + 1]) ++j;
            valid += (j - i + 1) * (j - i + 2) >> 1;
            rep (k, i, j) {
                int x = (k - i + 1) * (j - k + 1);
                ans[lx][ly][k] += x;
                ans[rx + 1][ly][k] -= x;
                ans[lx][ry + 1][k] -= x;
                ans[rx + 1][ry + 1][k] += x;
            }
        }
    }
    rep (k, 1, r) rep (i, 1, n) rep (j, 1, m)
        ans[i][j][k] += ans[i - 1][j][k] + ans[i][j - 1][k] - ans[i - 1][j - 1][k];
}

inline void calc() {
    int res = 0, sum;
    sum = qkpow(1ll * valid * qkpow(u, mod - 2) % mod, q);
    valid = qkpow(valid, mod - 2);
    rep (i, 1, n) rep (j, 1, m) rep (k, 1, r) {
        int p = (1 + mod - qkpow((1 + mod - 1ll * ans[i][j][k] * valid % mod) % mod, q)) % mod;
        p = 1ll * p * sum % mod;
        chkadd(res, 1ll * p * val[i][j][k] % mod);
    }
    writln(res);
}

signed main() {
    freopen("dream.in", "r", stdin);
    freopen("dream.out", "w", stdout);
    input();
    prelude();
    solve();
    calc();
    return 0;
}

等你哈苏德 / Wait

  并不明白题目的意思。

  区间覆盖并不需要关注整个数列，实际上我们只需要考察端点的情况就行了，换而言之，先转成前缀的情况，然后再关注每个端点的情况即可。在此基础上，注意到 "使得数轴上对于每个点，覆盖他的黑区间个数和白区间个数差的绝对值小于等于 1"，这引导我们向欧拉路方面考虑，因为欧拉路满足这条路上每个点的入度与出度之差小于等于 1，刚好和这道题匹配。

  离散化后，我们只需要关心每个端点处的差值。如果把区间 $[l, r]$ 视为 $l$ 和 $r$ 之间连了一条无向边，染色视作是定向，我们可以发现这就是一个欧拉路径问题。我们把奇度数的点排序后依次连接，跑欧拉回路即可。

  一部分线段染色相当于是混合图欧拉回路，跑网络流即可。由于这是个单位流量的图，所以 Dinic 算法可以快速跑出。

/** @author __Elaina__ */

// #pragma GCC optimize("Ofast")

#include <bits/stdc++.h>
using namespace std;

#define USING_FREAD
// #define NDEBUG
#include <cassert>

namespace Elaina {
/** その可憐な少女は魔女であり、旅人でした。 ―― そう、私です! */

#define rep(i, l, r) for(int i = (l), i##_end_ = (r); i <= i##_end_; ++i)
#define repf(i, l, r) for (int i = (l), i##_end_ = (r); i < i##_end_; ++i)
#define drep(i, l, r) for(int i = (l), i##_end_ = (r); i >= i##_end_; --i)
#define fi first
#define se second
#define mp(a, b) make_pair(a, b)
#define Endl putchar('\n')
#define whole(v) ((v).begin()), ((v).end())
#define bitcnt(s) (__builtin_popcount(s))
/** @warning no forced type conversion */
#define rqr(x) ((x) * (x))
#define y0 FUCK_UP
#define y1 MOTHER_FUCKER
#define masdf(...) fprintf(stderr, __VA_ARGS__)

typedef long long ll;
typedef unsigned long long ull;
typedef std::pair<int, int> pii;
typedef vector<int> vset;

template<class T> inline T fab(T x) { return x < 0 ? -x : x; }
template<class T> inline void chkmin(T& x, const T rhs) { x = std::min(x, rhs); }
template<class T> inline void chkmax(T& x, const T rhs) { x = std::max(x, rhs); }

#ifdef USING_FREAD
inline char qkgetc() {
# define BUFFERSIZE 1 << 20
    static char BUF[BUFFERSIZE], *p1 = BUF, *p2 = BUF;
    return p1 == p2 && (p2 = (p1 = BUF) + fread(BUF, 1, BUFFERSIZE, stdin), p1 == p2) ? EOF : *p1++;
# undef BUFFERSIZE
}
# define CHARRECEI qkgetc()
#else
# define CHARRECEI getchar()
#endif

template<class T> inline T readret(T x) {
    x = 0; int f = 0; char c;
    while (!isdigit(c = CHARRECEI)) if(c == '-') f = 1;
    for (x = (c ^ 48); isdigit(c = CHARRECEI); x = (x << 1) + (x << 3) + (c ^ 48));
    return f ? -x : x;
}
template<class T> inline void readin(T& x) {;
    x = 0; int f = 0; char c;
    while (!isdigit(c = CHARRECEI)) if (c == '-') f = 1;
    for (x = (c ^ 48); isdigit(c = CHARRECEI); x = (x << 1) + (x << 3) + (c ^ 48));
    if (f) x = -x;
}
template<class T, class... Args> inline void readin(T& x, Args&... args) {
    readin(x), readin(args...);
}
template<class T> inline void writln(T x, char c = '\n') {
    if (x < 0) putchar('-'), x = -x;
    static int __stk[55], __bit = 0;
    do __stk[++__bit] = x % 10, x /= 10; while (x);
    while (__bit) putchar(__stk[__bit--] ^ 48);
    putchar(c);
}

} // namespace Elaina
using namespace Elaina;

const int Maxn = 6e4;
const int Maxm = 1e6;

int m, n;
int l[Maxn + 5], r[Maxn + 5], w[Maxn + 5];
map<int, int> id;

int S, T, ncnt;
struct edge { int to, nxt, f; } e[Maxm << 1 | 1];
int tail[Maxn + 5], ecnt, cur[Maxn + 5];
inline void update(int i, int flow) { e[i].f -= flow, e[i ^ 1].f += flow; }
inline void add_edge(int u, int v, int f) {
    e[ecnt] = edge{v, tail[u], f}; tail[u] = ecnt++;
    e[ecnt] = edge{u, tail[v], 0}; tail[v] = ecnt++;
}

int prit[Maxn + 5], deg[Maxn + 5];
int corres[Maxn + 5];

int que[Maxn + 5], tl, hd;
int dis[Maxn + 5];
inline bool bfs() {
    memset(dis + 1, 0x3f, ncnt << 2);
    que[hd = tl = 1] = S, dis[S] = 0;
    for (int u = que[hd]; hd++ <= tl; u = que[hd]) {
        for (int i = tail[u], v; ~i; i = e[i].nxt) if (e[i].f) {
            if (dis[v = e[i].to] == 0x3f3f3f3f) que[++tl] = v, dis[v] = dis[u] + 1;
        }
    }
    return dis[T] != 0x3f3f3f3f;
}
int dfs(int u, int flow) {
    if (u == T) return flow;
    int used = 0, v;
    for (int& i = cur[u]; ~i; i = e[i].nxt) if (e[i].f) {
        if (dis[v = e[i].to] == dis[u] + 1) {
            int ret = dfs(v, min(flow - used, e[i].f));
            update(i, ret), used += ret;
            if (used == flow) break;
        }
    }
    return used;
}
inline int dinic() {
    int mxf = 0;
    while (bfs()) {
        memcpy(cur + 1, tail + 1, ncnt << 2);
        mxf += dfs(S, 0x3f3f3f3f);
    }
    return mxf;
}

signed main() {
    // freopen("wait.in", "r", stdin);
    // freopen("wait.out", "w", stdout);
    readin(m, n), n = 0;
    rep (i, 1, m) {
        readin(l[i], r[i], w[i]), ++r[i];
        id[l[i]] = id[r[i]] = 1;
    }
    for (auto& it: id) it.se = ++n;
    ncnt = n;
    S = ++ncnt, T = ++ncnt;
    rep (i, 1, m) {
        l[i] = id[l[i]], r[i] = id[r[i]];
        prit[l[i]] ^= 1, prit[r[i]] ^= 1;
    }
    memset(tail, 0xff, sizeof tail);
    mt19937 rnd((unsigned)time(NULL));
    rep (i, 1, n) if (prit[i]) {
        if (i == n) return puts("-1"), 0;
        prit[i] ^= 1, prit[i + 1] ^= 1;
        int t = rnd() & 1; // randomly orient the edge
        ++deg[i + t], --deg[i + (t ^ 1)];
        add_edge(i + t, i + (t ^ 1), 1);
    }
    rep (i, 1, m) {
        if (w[i] == 0) ++deg[l[i]], --deg[r[i]];
        else if (w[i] == 1) ++deg[r[i]], --deg[l[i]];
        else if (rnd() & 1) {
            w[i] = 1;
            ++deg[r[i]], --deg[l[i]];
            corres[i] = ecnt;
            add_edge(r[i], l[i], 1);
        }
        else {
            w[i] = 0;
            ++deg[l[i]], --deg[r[i]];
            corres[i] = ecnt;
            add_edge(l[i], r[i], 1);
        }
    }
    int mxf = 0;
    rep (i, 1, n) if (deg[i] != 0) {
        if (deg[i] > 0) add_edge(S, i, deg[i] >> 1), mxf += deg[i] >> 1;
        else add_edge(i, T, (-deg[i]) >> 1);
    }
    int res = dinic();
    if (res ^ mxf) return puts("-1"), 0;
    rep (i, 1, m) {
        if (corres[i] && e[corres[i] ^ 1].f) w[i] ^= 1;
        writln(w[i], " \n"[i == m]);
    }
    return 0;
}

喜欢最最痛 / Love

  答案分成两个部分：对于一个 $K$，$dp_i$ 表示加 $i$ 条额外边且 必须走 的代价，和前 $K$ 个加边代价中的前 $i$ 小和。而 必须走这 $i$ 条边 在 林克卡特树 中也有体现 —— 实际上就是在这个树上选 $i$ 条边不相交的链使得权值最大。

  因此我们可以使用树形 DP 解决在树上选择 $i$ 条最大权的边不交的链。时间复杂度为 $\mathcal O(n^2)$ 或 $\mathcal O(nm)$：

int siz[Maxn + 5];
void dfs1(int u, int par) {
    siz[u] = 1;
    for (const auto& [v, w]: g[u]) if (v ^ par)
        dfs1(v, u), siz[u] += siz[v];
}
ll f[Maxn + 5][Maxn + 5][2];
ll tmp[Maxn + 5][2];
void dfs2(int u, int par) {
    f[u][0][0] = 0;
    for (const auto& [v, w]: g[u]) if (v ^ par) {
        dfs2(v, u);
        for (int i = 0; i <= siz[u]; ++i)
            tie(tmp[i][0], tmp[i][1]) = tie(f[u][i][0], f[u][i][1]);
        for (int i = 0; i <= siz[u]; ++i) {
            for (int j = 0; j <= siz[v]; ++j) {
                chkmax(tmp[i + j][0], f[u][i][0] + f[v][j][0]);
                chkmax(tmp[i + j][1], f[u][i][1] + f[v][j][0]);
                chkmax(tmp[i + j][1], f[u][i][0] + f[v][j][1] + w);
                chkmax(tmp[i + j][1], f[u][i][0] + f[v][j][0] + w);
                chkmax(tmp[i + j + 1][0], f[u][i][1] + f[v][j][1] + w);
                chkmax(tmp[i + j + 1][0], f[u][i][1] + f[v][j][0] + w);
                chkmax(tmp[i + j + 1][0], f[u][i][0] + f[v][j][0] + w);
                chkmax(tmp[i + j + 1][1], f[u][i][1] + f[v][j][0] + w);
                chkmax(tmp[i + j + 1][1], f[u][i][0] + f[v][j][1] + w);
            }
        }
        for (int i = 0; i <= siz[u]; ++i)
            tie(f[u][i][0], f[u][i][1]) = tie(tmp[i][0], tmp[i][1]);
    }
    rep (j, 0, siz[u])
        chkmax(f[u][j + 1][0], f[u][j][1]);
    // rep (j, 0, siz[u]) {
    //     masdf("f[%d, %d, %d] == %lld\n", u, j, 0, f[u][j][0]);
    //     masdf("f[%d, %d, %d] == %lld\n", u, j, 1, f[u][j][1]);
    // }
}

  考虑优化选择 $i$ 条不交且权值最大的链的过程，考虑使用与费用流类似的 悔过 操作，每次在这棵树上找直径，然后将直径的边翻转成负的。因为有负权边，所以考虑选择 LCT 或者树剖维护 DDP 来实现，时间复杂度应当为 $\mathcal O(n\log n)\sim \mathcal O(n\log^2 n)$.

  至于对于一个 $K$ 应当如何计算答案，注意到 $dp_i$ 是两个凸函数相加 —— 选择链的函数是斜率单减的，加额外边的函数是斜率单增的，因此我们可以在平衡树上二分出这个答案。

  具体地，我们需要在树剖上维护一个点的直径，以及该区间的符号被整体翻转之后（填上负号）的直径，然后其他情况用类似线段树维护线段最值的方法即可，需要讨论的东西有点多，需要 仔细一点......代码实现用的全局平衡二叉树，因此复杂度是 $\mathcal O(n\log n)$ 的。

/** @author __Elaina__ */

#pragma GCC optimize("O2")

#include <bits/stdc++.h>
using namespace std;

#define USING_FREAD
// #define NDEBUG
#include <cassert>

namespace Elaina {
/** その可憐な少女は魔女であり、旅人でした。 ―― そう、私です! */

#define rep(i, l, r) for(int i = (l), i##_end_ = (r); i <= i##_end_; ++i)
#define repf(i, l, r) for (int i = (l), i##_end_ = (r); i < i##_end_; ++i)
#define drep(i, l, r) for(int i = (l), i##_end_ = (r); i >= i##_end_; --i)
#define fi first
#define se second
#define mp(a, b) make_pair(a, b)
#define Endl putchar('\n')
#define whole(v) ((v).begin()), ((v).end())
#define bitcnt(s) (__builtin_popcount(s))
/** @warning no forced type conversion */
#define rqr(x) ((x) * (x))
#define y0 FUCK_UP
#define y1 MOTHER_FUCKER
#define masdf(...) fprintf(stderr, __VA_ARGS__)

typedef long long ll;
typedef unsigned long long ull;
typedef std::pair<int, int> pii;
typedef vector<int> vset;

template<class T> inline T fab(T x) { return x < 0 ? -x : x; }
template<class T> inline void chkmin(T& x, const T rhs) { x = std::min(x, rhs); }
template<class T> inline void chkmax(T& x, const T rhs) { x = std::max(x, rhs); }

#ifdef USING_FREAD
inline char qkgetc() {
# define BUFFERSIZE 1 << 20
    static char BUF[BUFFERSIZE], *p1 = BUF, *p2 = BUF;
    return p1 == p2 && (p2 = (p1 = BUF) + fread(BUF, 1, BUFFERSIZE, stdin), p1 == p2) ? EOF : *p1++;
# undef BUFFERSIZE
}
# define CHARRECEI qkgetc()
#else
# define CHARRECEI getchar()
#endif

template<class T> inline T readret(T x) {
    x = 0; int f = 0; char c;
    while (!isdigit(c = CHARRECEI)) if(c == '-') f = 1;
    for (x = (c ^ 48); isdigit(c = CHARRECEI); x = (x << 1) + (x << 3) + (c ^ 48));
    return f ? -x : x;
}
template<class T> inline void readin(T& x) {
    x = 0; int f = 0; char c;
    while (!isdigit(c = CHARRECEI)) if (c == '-') f = 1;
    for (x = (c ^ 48); isdigit(c = CHARRECEI); x = (x << 1) + (x << 3) + (c ^ 48));
    if (f) x = -x;
}
template<class T, class... Args> inline void readin(T& x, Args&... args) {
    readin(x), readin(args...);
}
template<class T> inline void writln(T x, char c = '\n') {
    if (x < 0) putchar('-'), x = -x;
    static int __stk[55], __bit = 0;
    do __stk[++__bit] = x % 10, x /= 10; while (x);
    while (__bit) putchar(__stk[__bit--] ^ 48);
    putchar(c);
}
template<class T> inline T listMax(const T& x) { return x; }
template<class T, class... Args> inline T listMax(const T& x, const Args&... args) {
    return max(x, listMax(args...));
}
template<class T> inline T listMin(const T& x) { return x; }
template<class T, class... Args> inline T listMin(const T& x, const Args&... args) {
    return min(x, listMin(args...));
}

} // namespace Elaina
using namespace Elaina;

const int Maxn = 1e5 * 3; // third times: threeDeglization & turning edge to nodes
const ll inf = 0x3f3f3f3f3f3f3f3f;

int n, m; ll sum;
ll cost[Maxn + 5];

struct edge { int to, nxt; } e[Maxn * 2 + 5];
int tail[Maxn + 5], ecnt, ncnt;
ll val[Maxn + 5]; // the value of the node
inline void link(int u, int v) {
    e[ecnt] = edge{v, tail[u]}; tail[u] = ecnt++;
    e[ecnt] = edge{u, tail[v]}; tail[v] = ecnt++;
}

inline void input() {
    readin(n, m), ncnt = n;
    memset(tail, 0xff, sizeof tail);
    int u, v, w;
    rep (i, 2, n) {
        readin(u, v, w), sum += w << 1;
        val[++ncnt] = w; // turn edge to node
        link(u, ncnt), link(ncnt, v);
    }
    rep (i, 1, m) readin(cost[i]);
}


/** <-------------------------  ThreeDeglization  -------------------------> */
vset g[Maxn + 5];
inline void add_edge(int u, int v) {
    g[u].push_back(v), g[v].push_back(u);
}
void rebuild(int u, int par) {
    vset son;
    for (int i = tail[u], v; ~i; i = e[i].nxt) if ((v = e[i].to) != par)
        rebuild(v, u), son.push_back(v);
    if (son.size() < 3) {
        for (const int& v: son) add_edge(u, v);
    } else {
        int len = son.size() - 2; // apply the node [ncnt + 1, ncnt + len]
        repf (i, ncnt + 1, ncnt + len) add_edge(i, i + 1);
        add_edge(u, son[0]), add_edge(u, ncnt + 1);
        add_edge(ncnt + len, son.back()), son.pop_back();
        repf (i, 1, son.size()) add_edge(ncnt + i, son[i]);
        ncnt += len;
    }
}


/** <-------------------------  The Preparation for Building The GBBT - Part1  ------------------------->*/
int siz[Maxn + 5], wson[Maxn + 5], fa[Maxn + 5], dep[Maxn + 5];
int tp[Maxn + 5], dfn[Maxn + 5], id[Maxn + 5], tl[Maxn + 5], rt[Maxn + 5];
void dfs1(int u, int par) {
    siz[u] = 1, fa[u] = par, dep[u] = dep[par] + 1;
    for (const int& v: g[u]) if (v ^ par) {
        dfs1(v, u), siz[u] += siz[v];
        if (siz[v] > siz[wson[u]]) wson[u] = v;
    }
}


/** <-------------------------  Globally Balanced Binary Tree  -------------------------> */
struct chain {
    int u, v; ll d;   // u is the shallower one
    inline bool operator <(const chain& rhs) const {
        if (d != rhs.d) return d < rhs.d;
        else return u == rhs.u? v < rhs.v: u < rhs.u;
    }
};
struct node {
    int ls, rs;
    int l, r;                     // the interval
    ll val, sum;                  // the value and sum of the subtree
    chain tol[2], tor[2], mxx[2]; // the to-left chain & to-right chain, and the max length of the cahin
    int tag;                      // reverse tag
} tre[Maxn + 5];
typedef pair<int, ll> lFromChain; // light-from chain
lFromChain tolight[Maxn + 5];     // the endpos & length
chain golight[Maxn + 5];          // the longest chain when go into the subtre of light son
chain inlight[Maxn + 5];          // the longest chain in the light son
#define atls(i) tre[tre[i].ls]
#define atrs(i) tre[tre[i].rs]
inline void pushup(int i) {
    tre[i].l = tre[i].r = id[i];
    if (tre[i].ls) tre[i].l = atls(i).l;
    if (tre[i].rs) tre[i].r = atrs(i).r;
    tre[i].sum = atls(i).sum + atrs(i).sum + tre[i].val;
    for (int t = 0, sg = 1; t < 2; ++t, sg *= -1) {
        tre[i].tol[t] = listMax(
            atls(i).tol[t],
            chain{tre[i].l, atrs(i).tol[t].v, (tre[i].val + atls(i).sum) * sg + atrs(i).tol[t].d},
            chain{tre[i].l, tolight[id[i]].fi, (tre[i].val + atls(i).sum) * sg + tolight[id[i]].se}
        );
        tre[i].tor[t] = listMax(
            atrs(i).tor[t],
            chain{tre[i].r, atls(i).tor[t].v, atls(i).tor[t].d + (tre[i].val + atrs(i).sum) * sg},
            chain{tre[i].r, tolight[id[i]].fi, tolight[id[i]].se + (tre[i].val + atrs(i).sum) * sg}
        );
        tre[i].mxx[t] = listMax(
            atls(i).mxx[t],
            atrs(i).mxx[t],
            chain{atls(i).tor[t].v, tolight[id[i]].fi, atls(i).tor[t].d + tre[i].val * sg + tolight[id[i]].se},
            chain{tolight[id[i]].fi, atrs(i).tol[t].v, tre[i].val * sg + tolight[id[i]].se + atrs(i).tol[t].d},
            chain{atls(i).tor[t].v, atrs(i).tol[t].v, atls(i).tor[t].d + atrs(i).tol[t].d + tre[i].val * sg},
            inlight[id[i]]
        );
    }
}
int build(int l, int r) {
    if (l > r) return 0;
    int pivot = l, sum = 0, pre = 0;
    rep (i, l, r) sum += siz[id[i]] - siz[wson[id[i]]];
    rep (i, l, r) {
        pre += siz[id[i]] - siz[wson[id[i]]];
        if ((pre << 1) > sum) { pivot = i; break; }
    }
    tre[pivot].l = tre[pivot].r = id[pivot];
    tre[pivot].val = tre[pivot].sum = val[id[pivot]];
    tre[pivot].mxx[0] = tre[pivot].tol[0] = tre[pivot].tor[0] = chain{pivot, tolight[pivot].fi, tolight[pivot].se + val[pivot]};
    tre[pivot].mxx[1] = tre[pivot].tol[1] = tre[pivot].tor[1] = chain{pivot, tolight[pivot].fi, tolight[pivot].se - val[pivot]};
    chkmax(tre[pivot].mxx[0], inlight[pivot]);
    chkmax(tre[pivot].mxx[1], inlight[pivot]);
    tre[pivot].ls = build(l, pivot - 1);
    tre[pivot].rs = build(pivot + 1, r);
    return pushup(pivot), pivot;
}
inline void uploadInfo(int u) {
    if (u != tp[u] || !fa[u]) return ; // no fake father
    golight[fa[u]] = tre[rt[u]].tol[0];
    inlight[fa[u]] = tre[rt[u]].mxx[0];
}
inline void updateLight(int u) {
    if (!u) return ;
    tolight[u] = {u, 0};
    if (golight[u].d > tolight[u].se)
        tolight[u] = {golight[u].v, golight[u].d};
}
inline void flip(int i) {
    if (!i) return ;
    tre[i].val = -tre[i].val, tre[i].sum = -tre[i].sum;
    swap(tre[i].tol[0], tre[i].tol[1]);
    swap(tre[i].tor[0], tre[i].tor[1]);
    swap(tre[i].mxx[0], tre[i].mxx[1]);
    tre[i].tag ^= 1;
}
inline void pushdown(int i) {
    if (!tre[i].tag) return ;
    flip(tre[i].ls), flip(tre[i].rs), tre[i].tag = 0;
}
inline void modify(int i, int l, int r, int ql, int qr) {
    if (!i || ql > qr) return ;
    if (ql <= l && r <= qr) return flip(i);
    pushdown(i);
    if (ql <= i && i <= qr) tre[i].val = -tre[i].val;
    if (ql < i) modify(tre[i].ls, l, i - 1, ql, qr);
    if (i < qr) modify(tre[i].rs, i + 1, r, ql, qr);
    pushup(i);
}
inline void updateAll(int i, int to) {
    if (!i) return ;
    pushdown(i);
    if (to < i) updateAll(tre[i].ls, to);
    else if (i < to) updateAll(tre[i].rs, to);
    pushup(i);
}


/** <-------------------------  The Preparation for Building The GBBT - Part2  -------------------------> */
void dfs2(int u) {
    dfn[u] = ++*dfn, id[dfn[u]] = u, tl[tp[u]] = u;
    tolight[u] = {u, 0}, golight[u] = chain{-1, -1, 0};
    if (wson[u]) {
        tp[wson[u]] = tp[u]; dfs2(wson[u]);
        for (const int& v: g[u]) if (v ^ fa[u] && v ^ wson[u])
            dfs2(tp[v] = v);
    }
    if (u == tp[u]) {
        rt[u] = build(dfn[u], dfn[tl[u]]);
        uploadInfo(u), updateLight(fa[u]);
    }
}

inline void rever(int u, int v) {
    if (u < 1 || v < 1) return ;
    while (tp[u] ^ tp[v]) {
        if (dep[tp[u]] < dep[tp[v]]) swap(u, v);
        modify(rt[tp[u]], dfn[tp[u]], dfn[tl[tp[u]]], dfn[tp[u]], dfn[u]);
        uploadInfo(tp[u]);
        updateLight(u = fa[tp[u]]);
        updateAll(rt[tp[u]], dfn[u]);
    }
    if (dep[u] > dep[v]) swap(u, v);
    modify(rt[tp[u]], dfn[tp[u]], dfn[tl[tp[u]]], dfn[u], dfn[v]);
    while (fa[tp[u]]) {
        uploadInfo(tp[u]);
        updateLight(u = fa[tp[u]]);
        updateAll(rt[tp[u]], dfn[u]);
    }
    updateLight(tp[u]);
}

ll ans[Maxn + 5], dp[Maxn + 5];
namespace saya {

mt19937 rnd(0xcbdd1);
int son[Maxn + 5][2];
ll val[Maxn + 5], sum[Maxn + 5];
int siz[Maxn + 5];
unsigned rd[Maxn + 5];
int ncnt, rt;

inline int newnode(ll v) {
    int x = ++ncnt;
    val[x] = sum[x] = v, siz[x] = 1;
    rd[x] = ((rnd() ^ rnd() & rnd() | rnd()) & 0x7fff) << 15 | (rnd() ^ rnd() & rnd() | rnd());
    return x;
}
struct mypair {
    int c[2];
    inline int& operator [](int id) { return c[id]; }
};
inline void pushup(int x) {
    siz[x] = siz[son[x][0]] + siz[son[x][1]] + 1;
    sum[x] = sum[son[x][0]] + sum[son[x][1]] + val[x];
}
mypair split(int x, ll k) {
    if (!x) return {0, 0};
    int d = val[x] < k;
    auto ret = split(son[x][d], k);
    son[x][d] = ret[d ^ 1], ret[d ^ 1] = x;
    pushup(x);
    return ret;
}
int merge(int x, int y) {
    if (!x || !y) return x ^ y;
    int ret = 0xcbdd1;
    if (rd[x] < rd[y]) son[x][1] = merge(son[x][1], y), pushup(ret = x);
    else son[y][0] = merge(x, son[y][0]), pushup(ret = y);
    return ret;
}
inline void insert(ll k) {
    auto tmp = split(rt, k);
    rt = merge(merge(tmp[0], newnode(k)), tmp[1]);
}
inline ll query(int x, int cur) {
    if (!x) return dp[cur];
    int lsz = siz[son[x][0]] + 1;
    ll calc = val[x] + dp[cur + lsz] - dp[cur + lsz - 1];
    if (calc >= 0) return query(son[x][0], cur);
    return sum[son[x][0]] + val[x] + query(son[x][1], cur + lsz);
}

} // namespace saya

inline void solve() {
    ans[0] = dp[0] = sum;
    rep (i, 1, m) {
        chain diamet = tre[rt[1]].mxx[0];
        dp[i] = dp[i - 1] - diamet.d;
        rever(diamet.u, diamet.v);
    }
    rep (i, 1, m) {
        saya::insert(cost[i]);
        ans[i] = saya::query(saya::rt, 0);
    }
    rep (i, 0, m) writln(ans[i], " \n"[i == m]);
}

signed main() {
    freopen("love.in", "r", stdin);
    freopen("love.out", "w", stdout);
    input();
    rebuild(1, 0);
    tre[0].mxx[0] = tre[0].tol[0] = tre[0].tor[0] = chain{0, 0, -inf};
    tre[0].mxx[1] = tre[0].tol[1] = tre[0].tor[1] = chain{0, 0, -inf};
    dfs1(1, 0);
    dfs2(tp[1] = 1);
    solve();
    return 0;
}