E. There Should Be a Lot of Maximums

题意：给你一个树去掉一条边后变成两棵树，在两棵树上分别找到最大的出现两次的树后取max.

做法：先给每条边分配一个答案id后，进行两次相反的启发式合并，一次在空树上加上贡献，第二次在贡献满掉后，给每棵树剪掉贡献取两次的最大值。

 

 #include<bits/stdc++.h>
#define int long long
#define AC return 0;
#define all(tar) tar.begin(), tar.end()
#define INF = de0b6b3a7640000;
using namespace std;
typedef pair<int, int> pii;
const int maxx = 1000005;
const int mod = 1e9 + 7;
int n, m, t;
vector<int>G[maxx];
int siz[maxx];
int son[maxx];
vector<int>num;
int ans[maxx];
vector<int>k[maxx];
int pos[maxx];
int sum[maxx];
set<int>st;
int val[maxx];
void dfs1( int u, int fa ) { //遍历整个树，找每个点的重儿子

    siz[u] = 1;
    //cout << u << " " << pos[u] << '\n';
    for ( int i = 0; i < G[u].size(); i ++ ) {

        int v = G[u][i];

        if ( v == fa ) continue;
        pos[v] = k[u][i];
        dfs1( v, u );

        siz[u] += siz[v];

        if ( ! son[u] || siz[v] > siz[son[u]] )

            son[u] = v;

    }

}
void  add(int x) {
    sum[x]++;
    if (sum[x] >= 2 && !st.count(x))st.insert(x);
}
void dele(int x) {
    sum[x]--;
    if (sum[x] == 1)st.erase(x);
}
void modify( int u, int fa, bool flag ) {//flag=0回退 flag=1添加
    if ( flag ) {
        add(val[u]);
    } else {
        dele(val[u]);
    }
    for ( int i = 0; i < G[u].size(); i ++ )
        if ( G[u][i] != fa ) modify( G[u][i], u, flag );
}
void dfs2( int u, int fa ) {
    for ( int i = 0; i < G[u].size(); i ++ ) {
        int v = G[u][i];
        if ( v == fa || v == son[u] ) continue;
        dfs2( v, u );//先算轻儿子的答案
        modify( v, u, 0 );//计算完轻儿子的答案后 要把儿子的痕迹擦干净 为下一个儿子准备
    }
    if ( son[u] )dfs2( son[u], u ); //重儿子的贡献仍然保留 不回退
    for ( int i = 0; i < G[u].size(); i ++ ) {
        int v = G[u][i];
        if ( v == fa || v == son[u] ) continue;
        modify( v, u, 1 );//计算完轻儿子的答案后 要把儿子的痕迹擦干净 为下一个儿子准备
    }
    add(val[u]);
    if (!st.empty())ans[pos[u]] = max(*st.rbegin(), ans[pos[u]]);
}
void dfs3( int u, int fa ) {
    for ( int i = 0; i < G[u].size(); i ++ ) {
        int v = G[u][i];
        if ( v == fa || v == son[u] ) continue;
        dfs3( v, u );//先算轻儿子的答案
        modify( v, u, 1 ); //计算完轻儿子的答案后 要把儿子的痕迹擦干净 为下一个儿子准备
    }
    if ( son[u] )dfs3( son[u], u ); //重儿子的贡献仍然保留 不回退
    for ( int i = 0; i < G[u].size(); i ++ ) {
        int v = G[u][i];
        if ( v == fa || v == son[u] ) continue;
        modify( v, u, 0 );//计算完轻儿子的答案后 要把儿子的痕迹擦干净 为下一个儿子准备
    }
    dele(val[u]);
    if (!st.empty())ans[pos[u]] = max(*st.rbegin(), ans[pos[u]]);
}
signed main() {
    std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> n;
    int cnt = 0;
    for (int i = 1; i < n; i++) {
        int x, y;
        cin >> x >> y;
        G[x].push_back(y);
        G[y].push_back(x);
        k[x].push_back(++cnt);
        k[y].push_back(cnt);
    }
    for (int i = 1; i <= n; i++)cin >> val[i], num.push_back(val[i]);
    sort(all(num));
    num.erase(unique(all(num)), num.end());
    for (int i = 1; i <= n; i++) {
        val[i] = lower_bound(all(num), val[i]) - num.begin() + 1;
    }
    dfs1(1, -1);
    dfs2(1, -1);
    memset(sum, 0, sizeof sum);
    st.clear();
    for (int i = 1; i <= n; i++)add(val[i]);
    dfs3(1, -1);
    for (int i = 1; i < n; i++) {
        if (ans[i]) {
            cout << num[ans[i] - 1] << " ";
        } else cout << 0 << " ";
    }
    AC
}