bzoj3669 [Noi2014]魔法森林 LCT

Description

---

给定一张n个点m条边的无向图，每条边有两个权值ai和bi。问一条联通1到N的路径上最大的ai+bi最小是多少
如果无论如何小E都无法拜访到隐士，输出“-1”（不含引号）。

2<=n<=50,000
0<=m<=100,000
1<=ai ,bi<=50,000

Solution

---

一个脑洞就是看到最大值最小想到二分答案然后上spfa，不过复杂度比较神奇

另一个做法就是LCT。注意到这里是边权要先化为点权
因为权值有两个因此想到限定一个求另一个最小，即对a排序动态维护b的最小生成树，每次用ai+maxb更新答案

Code

---

#include <stdio.h>
#include <string.h>
#include <algorithm>
#define rep(i,st,ed) for (int i=st;i<=ed;++i)

const int INF=0x3f3f3f3f;
const int N=400005;
const int E=400005;

struct treeNode {int son[2],fa,v,max,rev,is_root;} t[N];
struct edge {int x,y,a,b;} e[E];

int fa[N];

int read() {
    int x=0,v=1; char ch=getchar();
    for (;ch<'0'||ch>'9';v=(ch=='-')?(-1):(v),ch=getchar());
    for (;ch<='9'&&ch>='0';x=x*10+ch-'0',ch=getchar());
    return x*v;
}

void push_up(int x) {
    t[x].max=std:: max(t[x].v,std:: max(t[t[x].son[0]].max,t[t[x].son[1]].max));
}

void push_down(int x) {
    if (!x||!t[x].rev) return ;
    t[t[x].son[0]].rev^=1;
    t[t[x].son[1]].rev^=1;
    std:: swap(t[x].son[0],t[x].son[1]);
    t[x].rev=0;
}

void rotate(int x) {
    if (t[x].is_root) return ;
    int y=t[x].fa; int z=t[y].fa;
    int k=t[y].son[1]==x;
    t[y].son[k]=t[x].son[!k];
    if (t[x].son[!k]) t[t[x].son[!k]].fa=y;
    t[x].son[!k]=y;
    t[y].fa=x; t[x].fa=z;
    if (t[y].is_root) {
        t[x].is_root=1;
        t[y].is_root=0;
    } else t[z].son[t[z].son[1]==y]=x;
    push_up(y); push_up(x);
}

void remove(int x) {
    if (!t[x].is_root) remove(t[x].fa);
    push_down(x);
}

void splay(int x) {
    remove(x);
    while (!t[x].is_root) {
        int y=t[x].fa; int z=t[y].fa;
        if (!t[y].is_root) {
            if ((t[y].son[1]==x)^(t[z].son[1]==y)) rotate(x);
            rotate(y);
        }
        rotate(x);
    }
}

void access(int x) {
    int y=0;
    do {
        splay(x);
        t[t[x].son[1]].is_root=1;
        t[t[x].son[1]=y].is_root=0;
        push_up(x);
        y=x; x=t[x].fa;
    } while (x);
}

void mroot(int x) {
    access(x); splay(x); t[x].rev^=1;
}

void link(int x,int y) {
    mroot(x); t[x].fa=y;
}

void cut(int x,int y) {
    mroot(x); access(y); splay(y);
    t[x].fa=t[y].son[0]=0;
    t[x].is_root=1;
    push_up(y);
}

int get_father(int x) {
    if (!fa[x]) return x;
    return fa[x]=get_father(fa[x]);
}

int query(int x,int y) {
    mroot(x); access(y); splay(y);
    if (!t[y].max) return y;
    while (t[y].max==t[t[y].son[0]].max||t[y].max==t[t[y].son[1]].max) {
        y=t[y].son[t[t[y].son[1]].max>t[t[y].son[0]].max];
    }
    return y;
}

bool cmp(edge a,edge b) {
    return a.a<b.a;
}

int main(void) {
    int n=read(),m=read();
    rep(i,1,m) e[i]=(edge) {read(),read(),read(),read()};
    std:: sort(e+1,e+m+1,cmp);
    rep(i,1,m) t[i+n].v=t[i+n].max=e[i].b;
    rep(i,1,n+m) t[i].is_root=1;
    int ans=INF;
    rep(i,1,m) {
        int fx=get_father(e[i].x);
        int fy=get_father(e[i].y);
        if (fx!=fy) {
            link(e[i].x,i+n);
            link(e[i].y,i+n);
            fa[fx]=fy;
        } else {
            int pos=query(e[i].x,e[i].y);
            if (e[i].b<t[pos].max) {
                cut(e[pos-n].x,pos);
                cut(e[pos-n].y,pos);
                link(e[i].x,i+n);
                link(e[i].y,i+n);
            }
        }
        if (get_father(1)==get_father(n)) {
            ans=std:: min(ans,e[i].a+t[query(1,n)].v);
        }
    }
    if (ans==INF) ans=-1;
    printf("%d\n", ans);
    return 0;
}