CF1296F - Berland Beauty 树链剖分

CF1296F - Berland Beauty

题意

$N$个点$N-1$条边的树，现在有$M$个条件：点$u$到点$v$的路径上权值最小的边为$w$
问你能不能构造出这样的边权满足所有条件，如果能输出每条边的边权，不能输出$-1$

题解

处理$u$到$v$的所有路径，这里用树剖即可
然后想到一条边有多个可能的权值，我们只能取最大的可能权值，因为取小了会使其他条件不符
所以将条件按$w$从大到小排序然后更新边权即可
每次更新，$u$到$v$的所有边里面，至少要有一条更新为$w$
因为之前更新的都是更大的值，所以是找还没赋值的边给更新掉
如果没有更新，说明前面的条件都满足的情况下，当前是不可能填一个更小的，填了就和前面的有冲突

代码

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define sz  sizeof
#define eps 1e-9
#define lowbit(x) x&-x
using namespace std;
typedef long long ll;
const int MAX = 5e3 + 10;

struct edge {
    int nxt, to, id;
} e[MAX << 1];
int head[MAX], tot;
void add(int u, int v, int id) { e[++tot] = edge{ head[u], v, id }; head[u] = tot; }

int N, M;
int f[MAX];

//树剖--------------------------
int siz[MAX], son[MAX], dep[MAX], fa[MAX], top[MAX];
int id[MAX], nodeOf[MAX], from[MAX], cnt;
void dfs(int u, int par) {
    dep[u] = dep[fa[u] = par] + (siz[u] = 1);
    for (int i = head[u], v; i; i = e[i].nxt)
        if ((v = e[i].to) != par) {
            dfs(v, u);
            from[v] = e[i].id;//化点为边
            siz[u] += siz[v];
            if (!son[u] || siz[v] > siz[son[u]])
                son[u] = v;
        }
}

void dfs2(int u, int topf) {
    nodeOf[id[u] = ++cnt] = u, top[u] = topf;
    if (!son[u]) return;
    dfs2(son[u], topf);
    for (int i = head[u], v; i; i = e[i].nxt)
        if ((v = e[i].to) != fa[u] && v != son[u]) dfs2(v, v);
}
//--------------------------

bool modify(int x, int y, int val) {
    bool flag = 0;//记录有没有更新
    while (top[x] != top[y]) {
        if (dep[top[x]] < dep[top[y]]) swap(x, y);
        //直接暴力扫一遍
        for (int i = id[top[x]]; i <= id[x]; i++) {
            if (f[from[nodeOf[i]]] == val) flag = 1;//如果前面更新的值和现在一样大，那也是更新了
            if (!f[from[nodeOf[i]]]) f[from[nodeOf[i]]] = val, flag = 1;//这个点还没赋值
        }

        x = fa[top[x]];
    }
    if (x != y) {
        if (dep[x] > dep[y]) swap(x, y);
        //暴力扫
        for (int i = id[son[x]]; i <= id[y]; i++) {
            if (f[from[nodeOf[i]]] == val) flag = 1;
            if (!f[from[nodeOf[i]]]) f[from[nodeOf[i]]] = val, flag = 1;
        }
    }
    return flag;
}

struct node {
    int u, v, w;
    bool operator < (const node &rhs) const {
        return w > rhs.w;
    }
} a[MAX];

int main() {

    scanf("%d", &N);
    for (int i = 1; i < N; i++) {
        int u, v; scanf("%d%d", &u, &v);
        add(u, v, i); add(v, u, i);
    }
    dfs(1, 0);
    dfs2(1, 1);
    scanf("%d", &M);
    for (int i = 1; i <= M; i++) scanf("%d%d%d", &a[i].u, &a[i].v, &a[i].w);
    sort(a + 1, a + 1 + M);//按w排序
    bool flag = 1;
    for (int i = 1; i <= M; i++)
        flag &= modify(a[i].u, a[i].v, a[i].w);//每次都得更新flag才是1
    if (flag) {
        for (int i = 1; i < N; i++)
            printf("%d%s", f[i] ? f[i] : (int)1e6, i == N - 1 ? "\n" : " ");
    }
    else printf("-1");

    return 0;
}